rapport de projet tutore - j.dul.free.frj.dul.free.fr/jeux/gcompris/rapport_gcompris.pdf ·...

RAPPORT DE PROJET TUTORE

Développement de modules pour

l’application libre Gcompris en C &

GTK.

2008-2009 IUT A INFORMATIQUE – BOURG EN BRESSE

Groupe 2A Informatique : BAILLY Bérenger, FAVERGE Cyrille,

FROUJY Sami et ODUL Jonathan

Projet tutore OK GCOMPRIS Développement de modules en C

BAILLY – FAVERGE – FROUJY – ODUL Page 1 sur 36

SOMMAIRE Sommaire _______________________________________________________________________ 1

1 Préambule __________________________________________________________________ 2

1.1 Présentation du travail __________________________________________________________ 2

1.2 Remerciements ________________________________________________________________ 2

2 Cahier des charges ____________________________________________________________ 3

2.1 Logiciel GCompris ______________________________________________________________ 3

2.2 Environnement et contraintes _____________________________________________________ 3

3 Etude préalable ______________________________________________________________ 5

3.1 Etude des logiciels concurrents ____________________________________________________ 5 3.1.1 Logiciel Adibou ______________________________________________________________________ 5 3.1.2 Logiciel Lapin Malin __________________________________________________________________ 5 3.1.3 Logiciel P'tit Bout _____________________________________________________________________ 6

3.2 Comparatif avec GCompris _______________________________________________________ 6

3.3 Choix de développement ________________________________________________________ 7

3.4 Plannings _____________________________________________________________________ 7

4 Partie Conception _____________________________________________________________ 9

4.1 Descriptions techniques _________________________________________________________ 9 4.1.1 Gcompris __________________________________________________________________________ 9 4.1.2 GooCanvas ________________________________________________________________________ 12

4.2 Modélisation UML _____________________________________________________________ 12 4.2.1 Digramme de cas d’utilisation __________________________________________________________ 12 4.2.2 Diagramme de séquence _____________________________________________________________ 14

4.3 Prototype d’interface ___________________________________________________________ 16

5 Partie Réalisation ____________________________________________________________ 19

5.1 Module « Apprendre la géographie » _____________________________________________ 19 5.1.1 L’idée ____________________________________________________________________________ 19 5.1.2 Manuel du programme _______________________________________________________________ 20

5.2 Insertion & Compilation dans Gcompris ___________________________________________ 24 5.2.1 Compilation de Gcompris à partir du code source __________________________________________ 24 5.2.2 Insertion d’un nouveau module _________________________________________________________ 25 5.2.3 Exemple : Le jeu du Pong _____________________________________________________________ 28

6 Conclusion _________________________________________________________________ 31

6.1 Difficultés rencontrées __________________________________________________________ 31 6.1.1 Organisation _______________________________________________________________________ 31 6.1.2 Compilation _______________________________________________________________________ 31 6.1.3 Développement ____________________________________________________________________ 32 6.1.4 Formation _________________________________________________________________________ 32

6.2 Bilan ________________________________________________________________________ 32

6.3 Avis du groupe _______________________________________________________________ 33

Glossaire ______________________________________________________________________ 34



1 PREAMBULE

1.1 Présentation du travail

Dans le cadre de notre formation au sein de l’IUT, nous allons réaliser un projet effectué en groupe de quatre étudiants et se déroulant pendant la seconde année de formation. Les projets sont encadrés notamment au travers de réunions régulières dirigées par Mme Dautraix. Ils s’achèvent par une soutenance orale devant un jury. Ce projet nous permet de travailler dans une relative autonomie et en groupe.

Cette année, le projet tutoré étant au choix pour chaque étudiant, notre groupe a décidé de travailler sur le projet « OK Gcompris ». Les informations publiées dans ce dossier sont protégées au titre du droit d’auteur.

Le dossier présenté est un rapport de projet tutoré concernant le groupe 2eme année Informatique, année 2009. Ce groupe est composé de :

- Cyrille FAVERGE, 2G2 IEM, Chef de projet - Bérenger BAILLY, 2G3 IG, - Sami FROUJY, 2G3 IG, - Jonathan ODUL, 2G3 IG

Toute reproduction partielle ou intégrale des documents est interdite sauf autorisation expresse de l’auteur. Toute utilisation commerciale des documents publiés à la bibliothèque de l’IUT A de Bourg en Bresse est strictement interdite.

Le projet portant sur le développement libre de logiciels, toutes les sources de nos créations sont régies par une licence publique générale limitée GNU*. Pour en savoir plus sur les termes de cette licence, visiter http://www.gnu.org/ .

Note : les mots suivis d’une astérix * sont définis dans le glossaire, situé en fin de dossier.

1.2 Remerciements

L’ensemble du groupe du projet tutoré souhaite remercier Mme Dautraix, tuteur du projet et

enseignante à l’IUT A, pour son suivi lors de ce projet ainsi que pour son aide. Nous souhaitons également

remercier Mr GUERIN, enseignant à l’IUT A, pour son aide technique au niveau de la compilation. Enfin,

nous souhaitons également remercier MR COUDOIN, créateur de Gcompris, pour son aide et sa patience

pendant tout le développement du projet.

De plus, nous remercions l’ensemble du corps professoral de l’IUT A pour la formation apportée

durant ces deux années au sein de l’IUT A Informatique. Cette formation nous a permis de mener à bien

un projet de manière professionnelle, avec les outils de notre formation allant de l’analyse à la

conception jusqu’au développement.



2 CAHIER DES CHARGES

2.1 Logiciel GCompris

GCompris est un logiciel éducatif très connu dans le milieu éducatif des jeunes enfants. C'est un logiciel qui propose plus de 50 activités dans les domaines suivants :

• découverte de l'ordinateur : clavier, souris, les mouvements de la souris, ... • mathématiques : révision des tables, dénombrement, les tables à double entrée, symétrie, ... • sciences : l'écluse, le cycle de l'eau, le sous-marin, ... • géographie : placer les pays sur une carte • jeux : des casses têtes, les échecs, le Memory, ... • lecture : exercice d'entraînement à la lecture • autres : lecture de l'heure, peintures célèbres sous forme de puzzle, dessin vectoriel, ...

GCompris est un logiciel libre. Il est implémenté de telle sorte qu’il est possible d’ajouter de nouvelles activités. Le sujet du projet tutoré se propose donc le développement d'une ou deux activités au choix des étudiants.

Le projet tutoré sur lequel notre groupe va travailler concerne donc le développement d’un, ou plusieurs modules pour l’application éducative GCompris.

Ce projet a été proposé en début d’année par Mr BOUTIN, professeur de mathématiques à l’IUT A. Ayant un enfant, il a voulu savoir quelles étaient les possibilités de logiciels destinés aux enfants. C’est donc naturellement qu’il s’est tourné vers le logiciel Gcompris. Il a donc proposé de rajouter des modules supplémentaires à cette application.

2.2 Environnement et contraintes

Nous devons créer un module qui se rattache au logiciel « GCompris ». Cela ne se fait pas n’importe comment et nous devons suivre des indications dites par les développeurs du jeu, afin que nous puissions faire un ou plusieurs modules compatibles avec le jeu.

Au niveau des contraintes de temps et de programmation, les modules pourront donc être programmés soit en C*, soit en Python*. En effet, le concepteur de Gcompris a permis aux autres développeurs de coder des modules dans deux langages différents, ceci pour des raisons de différences de faciliter d’adaptation ou encore de formations initiales suivant les personnes.

De plus, les modules doivent être compilés avec la librairie GTK*, ce qui nous oblige à nous former dessus avant de commencer la partie développement. Notre module, qui sera considéré comme un plugin, compatible, et reconnu par logiciel, notre code source devra contenir des fonctions portant des prototypes bien spécifiés. Le module devra contenir aussi un fichier XML* suivant une structure définie, qui caractérisera les informations de ce module, c'est-à-dire son nom, ses auteurs, sa description, son icône…



Nos modules devront adopter une ambiance très enfantine en évitant toutes sortes d’animations pouvant choquer les enfants (violence, sang…) et en respectant les mœurs. Nous avons le choix entre plusieurs thèmes qui sont la découverte de l’ordinateur, les mathématiques, les sciences, la géographie, les jeux, la lecture, et d’autres : tout ce qui peut améliorer et contribuer à l’éducation des enfants. Il faudra garder en tête, pendant toute la période de développement, que notre projet s’adresse directement des enfants.



3 ETUDE PREALABLE

Nous avons analysé différents logiciels concurrents afin de montrer les similitudes et les différences entre GCompirs et les autres logiciels. Cela nous a permis de mettre en évidence les différentes possibilités que nous pouvons inclure dans nos futurs modules.

3.1 Etude des logiciels concurrents

3.1.1 Logiciel Adibou

Adibou est le personnage principal d'une série de jeux vidéo éducatifs visant les 4-7 ans. Contrairement à GCompris, ce logiciel est payant. Il est donc développé par l’entreprise Mindscape. A titre d’information, Mindscape France est une entreprise de logiciels éducatifs française fondée en 1993 par Michel Bussac.

Adibou est composé de nombreux ateliers afin d’apprendre aux enfants comment reconnaître des pièces (triangulaires, carrées etc.…), ou encore des notions élémentaires comme lire ou compter. Ce logiciel pédagogique est donc sur certains points différents de notre projet puisque GCompris est un logiciel visant à apprendre à un enfant comme se servir d’un ordinateur, même si l’on retrouve tout de même des éléments d’apprentissage.

De plus, ce logiciel possède une collection variée regroupant les catégories suivantes : Lecture, Calcul, Découvertes et Aventures. Le client a donc le choix au niveau de l’orientation du logiciel en fonction de ses besoins. Il serait donc préférable de développer plusieurs modules visant ces différentes catégories, afin de répondre à un maximum de besoins du client.

En conclusion, nous pourrons essayer de développer un programme qui répondent aux critères de cette application, c'est-à-dire, un coté ludique pour apprendre à se servir d’un ordinateur tout en y associant un coté pédagogique pour mettre une notion d’apprentissage ou d’éveil chez l’enfant.

3.1.2 Logiciel Lapin Malin

Lapin Malin est un programme éducatif conforme au programme de l’éducation nationale. Lapin Malin est le personnage principal qui suit l’avancement du joueur tout au long des différentes aventures qu’il propose. Le personnage donne des conseils, nous parlera et devient interactif avec l’utilisateur.

Lapin Malin est composé de 8 jeux d’aventures éducatives de la première section de Maternelle au CE1, les enfants révisent les notions apprises à l’école: lecture, calcul, logique, compréhension, créativité, sciences, géographie, anglais…



Chaque titre raconte une nouvelle aventure parsemée d’activités éducatives, ce qui motive réellement les enfants dans leur quête d’aventure et de savoir. Les différentes activités ont donc chacun un lien dans le jeu afin de poursuivre son avancement, tandis que dans GCompris, chaque activité est autonome.

Réussir un jeu n’en affectera pas un autre, ou ne débloquera pas d’autres activités, ce qui peut donner aucune motivation à l’enfant. Lapin Malin étant aussi développé par des professionnels, le jeu propose donc beaucoup d’animation et d’interactivité avec le personnage.

3.1.3 Logiciel P'tit Bout

Logiciel éducatif pour les tous petits, P'tit bout est un logiciel s'adressant à l’enfant de 0 à 3 ans. Il permet aux enfants d'apprendre les couleurs, les formes, les cris des animaux et d’autres choses.

Son principe se rapproche beaucoup de celui de Gcompris en proposant des mini-activités (au nombre de 10) à thème. L'interface constituée de bouton-image facilitant la compréhension ainsi que le contenu de l’activité proposée rappelle aussi le logiciel Gcompris.

Néanmoins ce logiciel apporte aussi quelques plus par rapport au logiciel Gcompris avec notamment l'utilisation d'instruction audio pour guider l'enfant à travers les activités. Cela permet donc aux petits ne maitrisant pas tout à fait l'écrit de comprendre aisément les consignes et les manipulations à exécuter lors du déroulement d'une activité. L'utilisation d'instruction permet aussi de rendre le jeu plus agréable pour un enfant en rendant l'activité plus « interactive » et distrayante (en effet on peut supposer que l'utilisateur en bas âge préférera écouter plutôt que lire).

On notera malgré tout, comme pour le logiciel Gcompris, l'absence de bulle d'aide dynamique dans le cas où un utilisateur se retrouverait bloqué lors d'un jeu (par exemple signaler au début d'un jeu audio qu'il faut que les hauts parleurs soient allumés).

3.2 Comparatif avec GCompris

Dans le secteur des logiciels destinés aux plus jeunes d’entre nous, des logiciels concurrents affluent, et il n’est pas toujours évident de se démarquer de la concurrence. Il faut pour cela innover, et proposer des idées que les autres n’ont pas.

Gcompris est un logiciel intéressant et évolutif. Pour l’améliorer, il nous faut trouver des innovations inédites, et s’inspirer de ce que fait de mieux la concurrence.

Parmi les concurrents étudiés, on a pu retirer quelques idées qui nous semblent intéressantes d’exploiter, et peut-être d’intégrer dans nos futurs modules pour Gcompris. Tout d’abord, le logiciel possède certaines contraintes, donc toutes les idées proposées ne pourront peut-être pas être toutes implémentées. On retient notamment :

-l’intégration de jeux sonores.

-avoir un compagnon/animal qui nous accompagnera sur différents modules.



-rendre les modules plus animés (moins statiques que Gcompris).

-améliorer l’interface (plus de couleurs, des icones larges et animées).

-proposer des types de jeu inédit (jeu de mémoire, de réflexe, d’identification, de calcul, de sciences, de géographie, d’anglais …..)

Ces principales idées proviennent de l’analyse concurrentielle, mais également de notre propre réflexion. Mais il faudra faire une sélection, basée sur la faisabilité en termes de temps, de contraintes matérielles, financières … et ainsi ne garder que les idées les plus pertinentes.

3.3 Choix de développement

Pour le choix du langage deux options se présentaient à nous:

− D'une part le langage C*, un langage que nous avons étudié l'année dernière, qui permet de réaliser un grand nombre d'applications et qui met en jeu un nombre restreint de concepts, ce qui facilite la maitrise et le développement dans ce langage.

− D'autre part le Python* qui est un langage que nous n'avons pas étudié dans le cadre de nos études qui se rapproche sensiblement du langage C mais qui intègre de nouveaux principes, par exemple la réflexivité.

Le projet étant à finir pour Mars, nous n’aurons pas le temps de nous appliquer à ce nouveau

langage qu’est le Python*, donc pour raison d’aisance avec le C*, nous favorisons ce langage pour le

développement des modules. Le fait de prendre ce langage nous permet aussi de passer plus de temps

à la maitrise de GTK* plutôt que de devoir maitriser la syntaxe et l'utilisation du langage Python*, et

ensuite seulement passer à l'apprentissage de GTK*.

Le choix de Linux* comme plateforme de développement découle directement de l'utilisation du langage C*, mais aussi par respect de l'esprit de « logiciel libre » venant de Gcompris. En effet le logiciel Gcompris est un logiciel ouvert, le choix de Linux*, plateforme du libre par défaut, s'est donc avéré en accord avec la philosophie du logiciel.

3.4 Plannings

Tout au long de notre projet, nous allons essayer, tant bien que mal, de respecter un planning prévisionnel. Ce planning est donc à titre indicatif. Cependant, nous présenterons en fin de projet le planning « réel »de nos activités durant ce projet, qui tendra à ressembler sensiblement à ce lui.



FIGURE 1- PLANNING PREVISIONNEL

Après fin du projet, voici le diagramme de Gant que nous pouvons établir :

FIGURE 2 - PLANNING FINAL



4 PARTIE CONCEPTION

La conception de logiciel met en œuvre un ensemble d'activités qui, à partir d'une demande d'informatisation d'un processus (cahier des charges complet), permettent la conception, l'écriture et la mise au point d'un logiciel (et donc de programmes informatiques) jusqu'à sa livraison au client. L'analyse fonctionnelle est utilisée au début d'un projet pour créer (conception) un produit. On détermine donc, par exemple, les fonctions principales, les fonctions secondaires et les fonctions contraintes d'un produit. Il est important de faire ce recensement afin d'effectuer un dimensionnement correct des caractéristiques du produit.

4.1 Descriptions techniques

Dans cette partie, nous allons décrire les composantes de notre projet d’un point de vue technique. Par un souci de clarté, nous mettons à votre disposition un glossaire recensent certains termes techniques précis.

4.1.1 Gcompris

L'architecture de GCompris se décompose en plusieurs sous dossiers.

A la racine, nous retrouvons tous les fichiers de configuration, nécessaire à la compilation, et certains exécutables qui seront présents à la suite de notre projet. On y retrouvera certains autres fichiers annexes, comme les aides à la compilation, icones...

Dans le sous dossier "src", nous trouverons pour chaque module, son propre dossier à son nom. Dedans, on y trouvera donc son code sources, ses ressources, son icone, au format SVG* (qui apparaitra dans le menu du logiciel interactif), et un fichier XML*. Le fichier XML* est très important puisque c'est lui qui donnera toutes les informations du module (nom, auteur, description...), lors de la liaison entre GCompris et de ce dernier.

Le dossier "boards" est semblable au dossier "src", et contient lui aussi des modules. Cependant, les modules que nous développerons seront placés dans le dossier "src". Lors de l'ajout d'un module, on devra donc penser à éditer le fichier Makefile.am du dossier où le module se trouve, en y ajoutant le chemin vers le répertoire de notre module.

Mis à part le dossier "src", on y retrouvera le dossier "po", qui contient un fichier important "POSTFILES.in" qui recense tous les fichiers XML* des modules qu'on incorporera dans GCompris lors de la compilation. Ainsi, lors de l'ajout d'un nouveau module, on doit ajouter dans ce fichier, le chemin vers ses fichiers XML*, codes sources, et ressources, que le compilateur se chargera d'inclure dans les fichiers à compiler.

Les modules déjà présents dans Gcompris possèdent déjà une architecture bien spécifique. Dans un module, GCompris appellera la fonction is_our_board() du module en passant par paramètre le nom du type contenu dans le fichier XML* en paramètre. Si le module se reconnait dans le nom du type, il retournera 1.



FIGURE 3 - EXEMPLE DE FICHIER XML* DANS GCOMPRIS

Par la suite, GCompris va donner la main au module en appelant la fonction start_board()

contenu dans celui-ci. A partir de ce moment, le module peut alors s'exécuter, et doit d'abord configurer la barre, et le fond écran avec les fonctions gcompris_bar_set(), et gcompris_set_background(). Le module pourra par appeler les fonctions pause_board(), pour mettre en pause le module, ou encore end_board(), pour l'arrêter, et redonner la main à GCompris. Si nous avons besoin de gérer les touches pressées par l'utilisateur, on utilisera la fonction key_press(), où Gcompris nous enverra les évènements concernant le clavier.



FIGURE 4 - ARCHITECTURE DE GCOMP

FIGURE 5 - VUE D'ENSEMBLE DE GCOMPRIS

Sources des schémas : gcompris.net



4.1.2 GooCanvas

Pour pouvoir développer notre projet, nous allons utiliser la bibliothèque GooCanvas. Cette bibliothèque est une API* puissante regroupant de nombreuses sous-bibliothèques comme GTK*, GDK ou Cairo : GooCanvas est complémenté avec la technologie 2D de Cairo, une bibliothèque Gnome*. De plus, l’ensemble des widgets* de GTK* sont embarqués dans GooCanvas. L’application GCompris est basée sur ces technologies, et nous allons, de manière analogue, commencer notre développement à l’aide de ces technologies.

GooCanvas, ainsi que Cairo ou encore GTK*, sont des bibliothèques logicielles graphiques libres. Plus précisément, GooCanvas est défini comme une API* de rendu vectoriel 2D indépendante du matériel. Les objets de base que l’on retrouve dans cette bibliothèque sont le rectangle, l’ellipse, le texte, l’image ou encore le réseau. L’ensemble d’un projet GooCanvas donne lieu à une interface graphique affichant les objets et vues possibles du programme.

Le principe du graphisme sous GooCanvas est basé par le chemin de point en point, en utilisant la spécification SVG*. Dès lors, nous pouvons réaliser différents modules que nous animerons à l’aide de transformations affines, telles que la rotation ou la translations. On retrouve également le zoom, le défilement ou encore l’impression à l’aide de Cairo, ce qui nous donnent une bonne accessibilité des fonctions de bases. L’outil Grab de ToolKit nous permet de confiner les événements de la souris et clavier dans la fenêtre, et ainsi d’y récupérer les interactions venant de l’utilisateur.

Nous avons également à notre disposition un table de mise en page des autres éléments (similaire à la GtkTable). GooCanvas prend également en charge les points dont la hauteur varie en fonction de leur largeur alloués, tels que les éléments de texte. Les éléments de textes possèdent des styles en cascade comme la largeur des lignes, le style lui-même, les couleurs...Etc.

Enfin, lors de l’exécution d’un programme développé avec GooCanvas, les objets statiques ne bougent pas tant que la toile/fenêtre est en défilement ou zoomée. Les objets peuvent être ordonnés en fonction de leur visibilité et le support par les différentes unités comme les pixels, les points, les pouces (inch) ou encore les millimètres permettent une précision appréciable dans le travail.

GooCanvas est donc une puissante API* dont l’évolutivité et l’extensibilité est de plus en plus important : le soutien à des milliers d'articles sur un grand domaine la rend efficace.

4.2 Modélisation UML

L’UML* (en anglais Unified Modeling Language, « langage de modélisation unifié ») est un langage graphique de modélisation des données et des traitements. C'est une formalisation très aboutie, qui va nous permettre d’analyser notre projet à l’aide de diagramme que nous allons maintenant étudiés.

4.2.1 Digramme de cas d’utilisation

Les diagrammes de cas d'utilisation sont des diagrammes UML* utilisés pour donner une vision globale du comportement fonctionnel d'un système logiciel. Un cas d'utilisation représente l'interaction entre un utilisateur (humain ou machine) et un système. Dans un diagramme de cas d'utilisation, les



utilisateurs sont appelés acteurs (actors), ils interagissent avec les cas d'utilisation (use cases). Voici le diagramme de notre projet :

FIGURE 6 - DIAGRAMME DE CAS D'UTILISATION

D’après ce diagramme de cas d’utilisation, nous pouvons en tirer les indications suivantes, respectant l’analyse UML* :

@ Nom : Utilisation du module GCompris

X Objectif : Permettre l’utilisation du module Gcompris par l’utilisateur.

X Acteur(s) : L’utilisateur final du logiciel.

X Pré-conditions : Le module doit être correctement implémenté dans le logiciel Gcompris, et doit être fonctionnel.

X Scénario : L’utilisateur lance le jeu Gcompris, choisit le module « Apprendre la géographie » dans la liste des modules proposés, et suit les instructions données en début de partie. En fonction des options de difficultés il devra alors trouver le pays correspondant à la capitale indiquée, soit trouver la position de la capitale avec comme indice le nom du pays. Une distance entre le « clic de réponse » et la position exacte de la capitale sera intégrée. <Partie susceptible de modification>

X Post-condition : L’utilisateur obtient un certain nombre de points en fonctions des réponses correctes fournies. Un message de fin apparaîtra alors si l’utilisateur obtient la moyenne ou non.



X Exceptions : L’utilisateur quitte prématurément le jeu avant d’avoir finit le module. Dans ce cas aucun point ne sera affiché.

@ Nom : Définition de la difficulté du module

X Objectif : Permettre le réglage de la difficulté du module

X Acteur(s) : L’utilisateur / L’administrateur

X Pré-conditions : Le module doit être correctement implémenté dans le logiciel Gcompris, et doit être fonctionnel.

X Scénario : L’administrateur définit les niveaux de difficultés possibles pour l’utilisateur. Celui-ci peut alors décider de choisir un niveau de difficulté parmi ceux proposés par l’administrateur.

X Post-condition : Les objectifs du jeu ne seront pas les mêmes en fonctions de la difficulté choisie.

X Exceptions : L’utilisateur laisse le niveau de difficulté par défaut, celui-ci est alors en facile si l’administrateur a permis l’utilisation du niveau facile.

@ Nom : Administration du module

X Objectif : Permettre à l’administrateur de choisir les modules voulus et définir le niveau (étoiles) du jeu

X Acteur(s) : L’administrateur

X Pré-conditions : Le module doit être correctement implémenté et fonctionnel dans le logiciel Gcompris.

X Scénario : L’administrateur définit le niveau du jeu en nombre d’étoiles. Il peut alors le rendre disponible ou non pour l’enfant, en fonction de son âge et de son niveau.

X Post-condition : Le jeu est disponible ou non dans le menu des modules proposés

X Exceptions : L’administrateur ne définit pas le niveau et ne choisit aucun module. Tout les modules seront alors disponible directement dans le menu du logiciel.

Note : L’utilisateur et l’administrateur sont des acteurs réels, qui sont les personnes qui feront interagir le système

4.2.2 Diagramme de séquence

Les diagrammes de séquences sont la représentation graphique des interactions entre les acteurs et le système selon un ordre chronologique dans la formulation Unified Modeling Language (UML*). On montre ces interactions dans le cadre d'un scénario d'un Diagramme des cas d'utilisation. Le but étant de décrire comment se déroule les actions entre les acteurs ou objets. Voici le diagramme concernant notre projet :



FIGURE 7 - DIAGRAMME DE SEQUENCE

Le déroulement d’une partie du module de Gcompris « Découverte de la géographie européenne » se passe dans l’ordre suivant :

L’utilisateur va sélectionner le module parmi tous les modules présents dans Gcompris. Par la suite, il va lancer une partie, Il sélectionne un niveau de difficulté. Un message s’affiche pour préciser les règles du jeu et le jeu démarre, les indices défilent à l’écran et l’utilisateur doit sélectionner sur la carte le bon pays ou la bonne ville.

UtilisateurUtilisateur Module GcomprisModule

GcomprisCarteCarte

Choix du module

Lancement d'une partie

Affichage des niveaux de difficulté

Choix du niveau

Affichage des règles

Affichage question

Réponse

Interrogation

Affichage du score



La partie s’arrête au bout de 10 pays/villes, et on affiche le score obtenu. Le score est calculé en fonction du niveau, et de la présence ou non d’indices au moment de la réponse de l’utilisateur. Le score est affiché, et l’utilisateur est invité à relancer une autre partie. Le jeu se termine.

4.3 Prototype d’interface

Après concertation au sein du groupe, nous en avons conclut plusieurs idées pouvant émaner du module. Voici les prototypes du futur module :

FIGURE 8 - PAGE D'ADMINISTRATION DU MODULE



FIGURE 9 - PROTOTYPE DU MODULE EN NIVEAU FACILE

FIGURE 10 - PROTOTYPE DU MODULE EN NIVEAU DIFFICILE



On retrouve dans ce prototype l'interface classique de Gcompris, avec les menus préexistant, comme le bouton « dés » pour choisir la difficulté ou encore le bouton « maison » pour retourner au menu principal. L'interface du jeu consiste en une carte d'Europe de couleur uniforme avec un cadre blanc situé sous la carte où l'on pourra afficher les indices à fournir. En fonction du niveau de difficulté, l'indice sera différent.



5 PARTIE REALISATION

La réalisation est la phase de développement pure. Durant cette partie, nous avons décidé de partager le groupe de travail en deux. Un premier groupe travaillera sur le développement du nouveau module, et l’autre groupe va travailler sur la compilation dans l’objectif d’une insertion de module dans Gcompris. Cette répartition des tâches va également nous permettre de gagner du temps, et de travailler au mieux sur tout le projet, et non que sur le module par exemple.

La répartition des tâches est la suivante :

- Mr BAILLY Bérenger et Mr FROUJY Sami, responsables du développement du nouveau module « Apprendre la géographie »

- Mr FAVERGE Cyrille et Mr ODUL Jonathan, responsables de la compilation et de l’insertion du module dans Gcompris.

5.1 Module « Apprendre la géographie »

5.1.1 L’idée

Le jeu « Apprendre la géographie » est un jeu à but éducatif avec pour objectif d'apprendre tout en s'amusant la géographie européenne aux enfants.

Cela consiste donc à fournir à l'utilisateur un certain nombre d'indices plus ou moins complexes en fonction du niveau de difficulté choisi ainsi qu'une carte d'Europe vierge de tout indice géographique sur laquelle l’utilisateur devra cliquer au bon endroit, donc sur le bon pays, correspondant à l'indice fourni.

On propose alors une série de 10 pays à trouver parmi les pays de l'Europe, et une fois la série achevée, on affiche le résultat obtenu pour permettre à l'utilisateur de constater l'évolution de sa connaissance géographique de l'Europe.

Le jeu possède plusieurs objectifs en fonction de la difficulté souhaitée.

Niveau facile :

X Affichage de l’objectif du jeu sous forme d’un texte :

« Vous devez trouver le pays correspondant à la capitale donnée en cliquant sur la carte »

X Affichage de l’indice sous la carte:

« Paris »

« Londres»

X On attend le clic de l’utilisateur sur la carte, si une bonne réponse est donnée on propose de trouver un nouveau pays, sinon on donne un nouvel indice pour trouver le pays. (x10)

X Une fois les dix pays trouvés, on calcule la note de l’utilisateur selon la formule suivante :



Note = (nombre de pays à trouver / nombre de clics) * 10.

On obtient ainsi une note sur 10 qui permet de déterminer si l’utilisateur obtient la moyenne ou non.

Niveau moyen & difficile :

Ces niveaux seront régies par le rayon du cercle, dans le lequel l’utilisateur doit cliquer pour avoir la bonne réponse. En facile, le rayon vaut 100 Kms, 50 Kms au niveau moyen et enfin 20 Kms pour le niveau de difficulté le plus élevé. Ces kilomètres sont réels au niveau de la carte.

5.1.2 Manuel du programme

Voici le manuel final du module « Apprendre la géographie Européenne » pour le logiciel Gcompris. Cette version à été adaptée à partir de notre premier programme « test », nous allons donc en expliquer les grandes lignes

I. Include

- gcompris/gcompris.h

On inclut la bibliothèque créé pour le logiciel GCompris. Elle va nous permettre d’utiliser les

fonctions pré-écrites par le créateur de GCompris. Cette bibliothèque inclus aussi la librairie

standard stdlib.h

- Math.h

Cette libraire va nous permettre d’utiliser différentes fonctions mathématiques pour calculer la

distance entre le clic et l’emplacement de la carte

- Unistd.h

L'en-tête de <unistd.h> définit des constantes et des types symboliques divers, et déclare

diverses fonctions.

II. Variables

Les Variables Globales :

− char * tab_ville[10] :

On déclare un tableau de 10 chaînes de caractères qui contiendra les 10 villes de notre jeu. On se limite volontairement à 10 pour ne garder que les principales villes européennes afin de ne pas trop compliquer le jeu, même si le rajout de ville se ferait facilement en allouant plus d'espace pour ce tableau. Ce tableau de chaînes DOIT être en global pour pouvoir être lu dans tout le code, dans le main et dans la fonction. En effet nous verrons par la suite que ce tableau doit être accessible dans la fonction « on_button_press_event » et que l'utilisation de variable globale nous facilitera la tâche lors de l'implémentation sur le logiciel GCompris



− int ville = -1 :

Cet entier Ville va contenir la position de la prochaine ville à jouer. C’est une sorte de compteur qui va nous permettre de savoir où en est l’utilisateur dans sa partie. Cette variable doit aussi être globale, pour pouvoir être accessible partout. On l'initialise par défaut à -1 par soucis d'exécution dans la fonction « on_button_press_event » qui sera détaillée plus loin dans ce manuel.

− Int result = 0 :

result va simplement contenir le score du joueur, cette variable va donc être modifiée tout au long de l'exécution du programme.

− char chaine[100] :

chaine va servir à stocker le texte dynamique que l’on va afficher à l’écran.

− int dist_max = 0 :

dist_max va servir à définir la distance maximale acceptée entre la position du clic de la souris et la position de la capitale. On va modifier cette variable en fonction du niveau de difficulté.

− GooCanvasItem *text_objectif :

Cette variable GooCanvasItem va être convertie en Text-item. On va afficher ensuite grâce à ce text_item afficher les noms des capitales à trouver sur la carte

− GooCanvasItem *text_indication :

Cette variable GooCanvasItem va être convertie en Text-item. On va afficher ensuite grâce à ce text_item la distance entre le clic de la souris et l’emplacement de la capitale.

− GooCanvasItem *image:

Cette variable GooCanvasItem va être convertie en GooCanvasImage. C’est cette image qui va nous servir à afficher la carte d’europe.

− GdkPixbuf *pixbuf :

On va créer un pixbuf pour ouvrir l’image en .png. Ensuite on va le passer en paramètre a la fonction pour créer notre GooCanvasImage.

Les Variables Locales : − int dist = 0;

C'est une variable locale à la fonction « on_button_press_event ». Elle permet de stocker la distance qui sépare la zone de clic et la zone entourant la capitale voulue pour pouvoir la comparer à la distance maximale autorisée.



• Algorithme :

> Définition arbitraire d'un tableau de 10 villes.

> Connexion du signal « button_press_event » à notre fonction « on_button_press_event » pour gérer le clic de souris.

• Algorithme (fonction) :

Notre fonction on-button-press-event est le cœur même du jeu, c’est elle qui va permettre l’interaction entre l’utilisateur et le programme.

La fonction s'exécute de la manière suivante :

En premier lieu, nous affichons un bref résumé de l'objectif à atteindre et lors du premier clic de souris,nous affichons la première carte d'Europe et nous incrémentons la variable « Ville » ce qui va nous permettre de commencer le jeu.

Si « Ville »( variable compteur qui contient le numéro de la ville à jouer) est comprise entre 0 et 10, alors nous allons effectuer un « switch case » sur cette variable. En fonction du résultat, nous serons dans une ville différente. On va alors récupérer la position du clic de la souris grâce à la structure « GdkEventButton *event » qui contient les coordonnées du clic de la souris, et faire un simple calcul par rapport au coordonnées de la ville sur la carte. La formule est :

Racine ( (event->x – ville->x ) ² + (event->y– ville->y ) ² )

Ville->x et Ville->y ont été lus directement en pixels sur la carte. Cette formule donne la distance en pixels. Pour obtenir des kilomètres, il faut la multiplier par la valeur du nombre de kilomètres par pixel. Pour le calculer, on compte le nombre de pixels sur toute la largeur, et on divise par la distance réelle en kilomètres, on obtient 4.4075 kilomètres par pixel.

La distance calculée est comparée à une valeur arbitraire, qui dépendra du niveau de difficulté. On peut prendre par exemple 50 kilomètres pour une difficulté moyenne ou 100 pour une difficulté facile (valeurs susceptibles de modification) .


BAILLY – FAVERGE – FROUJY – ODUL

Si la distance est inférieure à la valeur seuil, on passe à la ville suivante en incrémentant la variable ville pour qu'au prochain clic de souris la ville demandée ne soit pas la même, ainsi que la variable résultat et on modifie l'image pour afficher l

On répète ensuite ces opérations jusqu’à la dernière ville, où l’on va afficher le score. Ce score est calculé de la façon suivante : 1 point par bonne réponse, mais donne un maximum de 10 points

FIGURE 11 - EXEMPLE D'UTILISATIO

FIGURE 12 - EXEMPLE D'UTILISATION 2


ODUL

Si la distance est inférieure à la valeur seuil, on passe à la ville suivante en incrémentant la variable ville pour qu'au prochain clic de souris la ville demandée ne soit pas la même, ainsi que la variable résultat et on modifie l'image pour afficher l'image correspondant à la prochaine capitale.

On répète ensuite ces opérations jusqu’à la dernière ville, où l’on va afficher le score. Ce score est : 1 point par bonne réponse, mais -0.25 par tentative infructueuse, ce qui

donne un maximum de 10 points (cette méthode de calcul est sujette à modification par la suite

EXEMPLE D'UTILISATION

ATION 2

ODUL Page 23 sur 36

Si la distance est inférieure à la valeur seuil, on passe à la ville suivante en incrémentant la variable ville pour qu'au prochain clic de souris la ville demandée ne soit pas la même, ainsi que la

'image correspondant à la prochaine capitale.

On répète ensuite ces opérations jusqu’à la dernière ville, où l’on va afficher le score. Ce score est 0.25 par tentative infructueuse, ce qui

méthode de calcul est sujette à modification par la suite).


BAILLY – FAVERGE – FROUJY – ODUL

Finalement, une fois les 10 villes trouvées, on affiche un message de fin, en affichant le score.

Comme dit dans l'introduction de ce manuel, ce programme version finale de notre projet, de nombreuses améliorations vont être apportées lors du passages à Gcompris, notamment l'enchainement aléatoire des capitales, différents niveaux de difficultés, l'affichage de texte dynamique sur les images, etc. Mais ce programme permet de se faire une idée globale du projet en cours.

5.2 Insertion & Compilation

5.2.1 Compilation de Gcompris à partir du code source

La compilation permet de créer le programme à partir du code source. Pse résume en 3 étapes, voire commandes

Nous devons exécuter un script qui va tout d'abord faire des tests sur la machinecommande sh configure. Cela vaGooCanvas ou GTK* par exemplemodule, ainsi qu'un Makefile* pour l'architecture entière de GCompris.

FIGURE 13 - FIN DU JEU


ODUL


Comme dit dans l'introduction de ce manuel, ce programme ne peut être considéré comme une version finale de notre projet, de nombreuses améliorations vont être apportées lors du passages à Gcompris, notamment l'enchainement aléatoire des capitales, différents niveaux de difficultés, l'affichage

e sur les images, etc. Mais ce programme permet de se faire une idée globale du

Compilation dans Gcompris

Compilation de Gcompris à partir du code source

La compilation permet de créer le programme à partir du code source. Pour Gcompris, cette étape se résume en 3 étapes, voire commandes : sh configure, make et make install.

ous devons exécuter un script qui va tout d'abord faire des tests sur la machineconfigure. Cela va vérifier que toutes les dépendances sont bien installées

par exemple. Si tout est bon, ce script va générer tous les pour l'architecture entière de GCompris. Un Makefile*

ODUL Page 24 sur 36


ne peut être considéré comme une version finale de notre projet, de nombreuses améliorations vont être apportées lors du passages à Gcompris, notamment l'enchainement aléatoire des capitales, différents niveaux de difficultés, l'affichage

e sur les images, etc. Mais ce programme permet de se faire une idée globale du

our Gcompris, cette étape

ous devons exécuter un script qui va tout d'abord faire des tests sur la machine : c’est la dances sont bien installées comme

Si tout est bon, ce script va générer tous les Makefile* pour chaque Makefile* est un fichier qui va



regrouper toutes les commandes de compilation afin d'automatiser et faciliter la compilation complète d'un projet. Si un problème survient durant l’exécution de cette commande, le terminal va nous indiquer l’erreur en question, et par la suite nous devons la résoudre (installation d’un nouveau package car package manquant …).

Par la suite, nous aurons 2 possibilités : - Si le logiciel n'est pas installé, on pourra compiler toute l'architecture, qui va donc compiler un

par un chaque module, en faisait la liaison avec le moteur du jeu, puis l'installer proprement dans notre système d’exploitation.

- Si le logiciel a déjà été installé, et qu'on souhaite donc compiler, et installer un nouveau module, il nous suffira de nous rendre dans ce répertoire, et utiliser le Makefile* généré pour le compiler, et l'installer. Dans notre projet, c’est cette solution qui est envisagée pour l’insertion d’un module.

5.2.2 Insertion d’un nouveau module

Le principe d’insertion du module est directement lié à un tutoriel en anglais, disponible sur le site officiel de GCompris, partie Développeur (http://gcompris.net/-Developpeurs-). C’est donc à partir de ce tutoriel que n’avons entrepris l’inclusion d’un nouveau module dans Gcompris.

Pour commencer, nous allons tout d’abord parler du module propre. Ce dernier est rassemblé dans un dossier dont le nom doit être du type « nomdumodule-activity », contenu dans le dossier « src » de GCompris. On retrouvera dans ce dossier les codes sources de notre module, les images, les documents XML* et tout autres documents ayant une dépendance fonctionnelle avec le module à insérer (voir Figure 10 & 11)

FIGURE 14 - VUE GLOBALE D'UN MODULE



FIGURE 15 - VUE GENERALE DES MODULES

Par la suite va s’en suivre une multitude d’édition de fichier déjà présents dans Gcompris, afin de faire comprendre au logiciel qu’un nouveau module à été insérer, et qu’il faut désormais en tenir compte. Nous allons essentiellement éditer et donc modifier des fichiers Makefile*. Dans ces fichiers, on ajoutera par exemple le chemin du dossier du module, ou le nom du module afin d’insérer de manière manuelle le module.

Tout d’abord, parlons du fichier configure.in. Cette édition va consister à ajouter le fichier du module dans la liste des autres modules. Une fois les vérifications de la commande configure terminée, la commande va se référencée aux entrées du fichier configure.in pour y générer les Makefile* nécessaire à al compilation. Nous allons rajouter notre module dans la section AC_OUTPUT recensant tous les autres modules. Pour plus de clarté sur la syntaxe, nous vous invitons à ouvrir le configure.in et ceci pour chaque édition (voir Figure 12)



FIGURE 16 - EDITION DU FICHIER CONFIGURE.IN

Nous poursuivons par l’édition du fichier XML* du module : ce fichier doit être du type « nomdumodule.xml ». Comme vu précédemment dans le dossier, un fichier XML* d’un module de Gcompris possède une syntaxe bien précise et ficelée. Ce fichier va permettre de détailler au mieux le module lors de l’exécution de Gcompris : c’est grâce à ce fichier que nous précisons par exemple le titre, l’auteur, la description, le niveau de difficulté ou encore les crédits. Ce fichier sera lié au module lors de la compilation et de l’installation. Ces informations peuvent être retrouvées sur el menu principal de Gcompris, ainsi qu’avec le bouton d’aide, présent lors de l’exécution d’un module Gcompris.

Désormais, nous n’avons plus qu’a édité le fichier se trouvant au chemin src/Makefile.am. Dans ce fichier, nous exécutons de manière analogue à la première édition : nous ajoutons à la liste notre module. Ici, c’est dans la section SUBDIRS, c'est-à-dire le dossier ainsi que tout les sous dossiers de notre module.

Pour finir, il faut préciser à Gcompris qu’il faut générer des Makefile* propres aux modules, comme on peut le voir sur l’image. Avant tout, nous devons exécuter la commande « autoconf » permettant de vérifier la portabilité en effectuant de nombreux tests sur les spécificités de la machine ou l'on désire installer notre application. Comme nous l’avons dans le dossier, nous exécutons la commande configure. Une fois que cette commande s’est terminée et surtout s’est bien déroulée, on exécute soit la commande make, soit make install.



L’insertion du nouveau module est alors terminée. Il suffit d’exécuter de nouveau l’application Gcompris, de se rendre dans la section concernée (puzzle, expériences…) pour retrouver le nouveau module. Il ne reste plus qu’a jouer !

Remarque : pour tester le module sans avoir à lancer Gcompris, nous pouvons exécuter ce dernier à l’aide de la commande : ./runit.sh nomdumodule-activity. Cela va exécuter le programme indépendamment de Gcompris. De plus, cela peut permettre de débugger un programme défaillant ou tout bug pouvant survenir durant l’exécution du module. Il faut préalablement se placer dans le dossier « src » de Gcompris pour pouvoir exécuter cette commande.

5.2.3 Exemple : Le jeu du Pong

Du fait de lourdes contraintes de temps, le groupe de développement du module final n’avait pas encore terminé son module, lorsque le groupe concernant l’insertion avait fini. Nous avons donc entrepris le développement rapide d’un nouveau module simple, rapide et permettant de tester cette insertion. Ce module se résume au jeu Pong. Le jeu Pong fut le premier jeu crée sur machine, ce qui nous a amené naturellement à développer ce jeu, du fait de sa simplicité et aussi par nostalgie. Le principe du jeu est de faire rebondir une balle à l’aide d’une palette, et ainsi éviter de faire tomber la balle dans le vide. Ce jeu simple est développé pour l’occasion en C à l’aide de l’API* GooCanvas.

Tout d’abord, rappelons que nos codes sources (ici pong.c) sont organisés en fonction de la syntaxe des modules de Gcompris, c'est-à-dire avec les fonctions systèmes. On y retrouve les fonctions start_board () ou encore gcompris_bar_set_level(). De plus, nous avons créé un fichier XML* afin de rendre notre module détaillé, et optimisé pour Gcompris.

Dans un second temps, nous avons configuré notre application come décrit dans le tutoriel vu plus haut dans le dossier. Ces manipulations vont nous permettre l’insertion et la compilation d’un nouveau module dans Gcompris. Nous pouvons résumer ces opérations par l’édition de fichiers systèmes, suivi de 4 commandes.

Une fois toutes ces opérations terminées, nous avons donc testé notre nouveau module. Cependant, nous pouvons noter que notre module a été testé préalablement en terme de compilation, afin de vérifier sa fonctionnalité externe de Gcompris. Nous lançons alors Gcompris, puis nous retrouvons effectivement notre module.



FIGURE 17 - VISUALISATION POST-INSERTION

Notre module est bien dans la section « Fun », comme précisé dans nos sources. Il ne reste plus qu’a cliquer sur le module pour le lancer, et ainsi jouer au plus vieux jeu du monde !

FIGURE 18 - LE JEU PONG



Nous avons également pris le temps de mettre en place différent niveaux de difficulté afin de tester l’intégrité de Gcompris, ce qui s’est avéré un succès. La section « aide » répertorie bien toutes les informations contenue dans le fichier XML*, précédemment édité.

L’insertion d’un module est alors opérationnelle avec une première approche d’insertion, qui permettra nous l’espérons d’éviter des erreurs lors de l’insertion de notre module.



6 CONCLUSION

C’est finalement courant mars que nous avons pu enfin terminé notre projet. En effet, après quelques retards et de nombreuses difficultés, nous sommes arrivés à un résultat convenable, permettant de finaliser notre projet.

6.1 Difficultés rencontrées

Lors de ce projet tutoré, nous avons rencontres de nombreuses difficultés. Certaines d’entre elles ont été rapidement résolues, d’autres nous ont pris du temps pour être solutionnées et certaines ne le sont toujours pas.

6.1.1 Organisation

Une première difficulté, mineure, fut de s’attribuer des postes au sein du projet. En effet, n’ayant jamais réellement travaillé sur un projet de formation supérieure, nous ne savions pas comment aborder le sujet. C’est donc le poste de chef de projet qui fut déterminant pour toute la durée du projet, puisque c’est lui qui doit gérer l’équipe de travail. C’est finalement Cyrille FAVERGE qui fut désigné comme étant le chef de projet à l’unanimité

Une autre difficulté rencontrée au cours de ce projet fut l’assignation lors de la période de conception. En effet, abordant quasiment pour tous un domaine inconnu qui est celui de Gcompris et de la programmation en Goocanvas, nous avons longtemps débattu sur les différents objectifs et tâches pouvant être accomplies dans le laps de temps restant. C’est ainsi que le groupe s’est séparé en deux groupes de deux. En tant que chef de projet, Cyrille FAVERGE se devait de rester en contact avec le second groupe, afin de contrôler et d’aider le groupe entier.

6.1.2 Compilation

La plus grosse difficulté de compilation rencontrée fut lors de la formation à GooCanvas. En effet, il nous été alors impossible de compiler un simple HelloWorld (un programme basique) sous Linux*. Ceci fut un fort handicap puisque sans compilation, il était impossible de tester nos créations, même celles nous permettant de comprendre au mieux GooCanvas. Après un contact avec MR Guérin, professeur de programmation à l’IUT A, nous avons résolu ce problème à l’aide d’une commande spécialisée dans la compilation GooCanvas. Sans cela, aucune documentation Internet ne renseignait se genre d’informations, considérant sans soute que les personnes programmant sous GooCanvas connaissent toutes ces manipulations. Ce fut donc une bonne ressource que d’avoir des professeurs présents pour nous aider, et nous les en remercions.

De plus, nous pouvons rajouter que la compilation cette fois ci de Gcompris nécessite également un tutoriel détaillé. Contrairement à une majorité de logiciel libre sur le marché, Gcompris possède de nombreuses spécificités à éditer afin d’insérer un élément, tel qu’un plugin/module.



6.1.3 Développement

Lors de notre formation à GTK* (bibliothèque graphique de développement), nous avons constaté que GTK* n’était pas une API* suffisante ou assez puissante pour développer nos modules. De plus, par sureté, nous avons décidé de contacter via e-mail le développeur de Gcompris, Mr Bruno COUDOIN. C’est ce dernier qui nous a mis sur la voie de GooCanvas, une API* capable de développer ce genre de modules. La formation à GTK* nous a alors en partie aidé. Cependant, comme nous allons le voir dans la description technique, GooCanvas rassemble de nombreuses bibliothèques, dont GTK* : cette préformation à GTK* pourra alors nous servir, mais reste insuffisante.

Un autre problème qui est apparu fut la connexion « Signal-Slot » pour l’évènement « on-button-press-event » sur l’image de la carte d’europe. Nous avons constaté que cette fonction ne marchait pas, et suite à de nombreuses recherches, nous avons réalisé que les images ne pouvaient pas avoir directement accès à cette fonction. En effet l’image nécessitait l’utilisation d’une event-box pour pouvoir ensuite lui associer cette fonction, qui nous permettait par la suite de récupérer la position du clic de la souris sur la carte.

Le second problème majeur fut l’adaptation de ce programme « test » en programme final, via la transformation des fonctions Gtk en GooCanvas. En effet le peu de documentation et d’exemples disponibles pour cette librairie nous a posé certains soucis dans la compréhension de fonctions importantes pour mon programme, ce qui fut notamment le cas avec la création et le changement d’image.

6.1.4 Formation

La formation à GooCanvas peut se résumer à ce lien de la libraire Gnome* : http://library.gnome.org/devel/goocanvas/unstable/index.html. Nous avons remarqué qu’il s’agissait de la seule documentation officielle sur GooCanvas, qu’elle est en anglais et de plus ne propose que les prototypes des fonctions. Cela ne permet pas de savoir réellement le comportement de la fonction et nous oblige implicitement à tester chaque fonction pour retenir seulement celle qui nous intéresse. C’est donc un travail de longue haleine et occupant la plus grande partie du travail du groupe de développement.

6.2 Bilan

Durant cette année, nous avons pu appréhender la gestion d'une équipe, du temps avec tous les impératifs et les imprévus que cela entraîne.

Tout d'abord, ce projet tutoré nous a donné un second aperçu des enjeux du travail en équipe. En effet, afin de réaliser les objectifs définis en début de projet (programmer et insérer un module), il a fallu nous organiser et répartir les différentes tâches. Après la gestion du groupe, celle du temps est primordiale. Afin d'en perdre le moins possible, lorsque l'on travaille en équipe, il est important de coder proprement et de commenter son code pour que le reste de l'équipe puisse utiliser notre travail. L'avantage de travailler ainsi permet un gain de temps énorme car il est possible de concevoir plusieurs fonctions simultanément et de les assembler à la fin en ayant enlevé les bugs dans chacune d'elles.



Enfin, le projet tutoré nous a permis de mettre en application sur un cas pratique et ludique ce que nous avions appris au cours de cette année (Langage C*, UML* et gestion de projet), ce qui est très intéressant. Il nous a aussi été indispensable d'apprendre à travailler en équipe et à gérer notre temps. On pourrait peut-être juste regretter que cette année, le sujet que nous avons choisi ne correspondait pas réellement à nos attentes, mais nous à permis de découvrir un nouvel univers : celui de l’open source.

Ce fut une expérience enrichissante car il nous a permis d’étudier l’architecture d’un logiciel professionnel, d’apprendre l’utilisation d’une nouvelle libraire GooCanvas (et à travers elle GTK*), mais aussi de voir l’importance de la répartition des tâches dans un projet. En effet sans cette répartition, nous pensons que la réalisation du projet aurait pris un retard non négligeable et n’aurait donc peut être pas été aussi aboutie à la fin de la période donnée pour le réaliser.

6.3 Avis du groupe

Ce projet tutoré touchant à sa fin, il est temps pour nous tous d’en tirer un bilan.

Ce fut tout d’abord une très bonne aventure humaine, qui nous aura permis de travailler dans un petit groupe de quatre personnes, de développer un esprit collectif, et d’être vraiment solidaires entre nous.

Le fait de réaliser un projet de A à Z, de suivre toutes les étapes de sa genèse, de l’analyse au codage en passant par la conception, nous aura permis de mieux appréhender les futurs projets que nous aurons peut-être à mener dans notre future vie professionnelle . Durant ce projet, il nous a été nécessaire d’apprendre à déléguer aux autres les choses que nous étions incapables de réaliser, mais aussi de se faire confiance les uns les autres. En effet, dans un grand projet tel que celui-ci, il est impossible de tout faire soi-même, et il est vital pour sa bonne tenue de bien apprendre à travailler en groupe. Tout cela aura donc permis de nous apporter une vraie expérience dans la conduite d’un long projet de groupe.

D’autre part, le codage d’un module de Gcompris nous aura permis de replonger dans le codage en C, et cela ne peut être que bénéfique pour l’avenir. De plus, la découverte de nouvelles librairies nous a contraints à effectuer un travail de recherche et de documentation important, ce que nous serions certainement amenés à reproduire.

Durant ce projet, il nous a fallu faire face à de nombreuses difficultés, surtout au niveau du développement. Entre autres, certaines incohérences de codage ont été rencontrées, et la principale difficulté était de maitriser ces erreurs et de les contourner. Il a fallu toute notre compétence intellectuelle pour les contourner. De plus, il nous a fallu bien comprendre et s’imprégner de la philosophie de GCompris, c’est-à-dire l’ambiance Linux*, et l’esprit du libre.



GLOSSAIRE

Retrouver dans cette partie tout les termes techniques employés dans ce dossier :

• API : Une interface de programmation (Application Programming Interface ou API) est un

ensemble de fonctions, procédures ou classes mises à disposition des programmes informatiques

par une bibliothèque logicielle, un système d'exploitation ou un service.

• C : Le C est en informatique un langage de programmation impératif conçu pour la

programmation système. Inventé au début des années 1970 avec UNIX, C est devenu un des

langages les plus utilisés. De nombreux langages plus modernes comme C++, PHP et Java

reprennent des aspects de C.

• Gnome : Gnome est un environnement de bureau libre convivial, dont l’objectif est de rendre

accessible l’utilisation du système d’exploitation GNU au plus grand nombre.

• GNU : La Licence publique générale GNU, ou GNU General Public License (son seul nom officiel

en anglais, communément abrégé GNU GPL voire simplement couramment « GPL ») est une

licence qui fixe les conditions légales de distribution des logiciels libres du projet GNU. Richard

Stallman et Eben Moglen, deux des grands acteurs de la Free Software Foundation, en furent les

premiers rédacteurs. Sa dernière version est la GNU GPL version 3 publiée le 29 juin 2007.

• GTK : The GIMP Toolkit est un ensemble de bibliothèques logicielles, c'est-à-dire un ensemble de

fonctions informatiques, permettant de réaliser des interfaces graphiques. Son nom vient du

logiciel GIMP, un logiciel libre permettant de réaliser des réalisations graphiques comme Paint ou

Photoshop.

• Linux : Linux, ou GNU*/Linux, est un système d'exploitation compatible POSIX. Linux est basé sur

le noyau Linux, logiciel libre créé en 1991 par Linus Torvalds pour ordinateur compatible PC.

• Makefile : Les Makefiles sont des fichiers, généralement appelés makefile ou Makefile, utilisés

par le programme make pour exécuter un ensemble d'actions, comme la compilation d'un projet,

l'archivage de document, la mise à jour de site, etc. Cet article présentera le fonctionnement de

makefile au travers de la compilation d'un petit projet en C.

• Python : il s’agit d’un langage de programmation interprété multi-paradigme. Il favorise la

programmation impérative structurée, et orientée objet. Il est doté d'un typage dynamique fort,

d'une gestion automatique de la mémoire par ramasse-miettes et d'un système de gestion

d'exceptions ; il est ainsi similaire à Perl, Ruby, Scheme, Smalltalk et Tcl.

• SVG : Scalable Vector Graphics (Graphiques de vecteurs évolutifs), de sigle SVG, est un format

de données conçu pour décrire des ensembles de graphiques vectoriels. Cette technologie est

basée sur le langage XML* (un langage à balises comme HTML, permettant de stocker des

données)

• UML : UML (en anglais Unified Modeling Language, « langage de modélisation unifié ») est un

langage graphique de modélisation des données et des traitements. C'est une formalisation très

aboutie et non-propriétaire de la modélisation objet utilisée en génie logiciel.

• Widget : Contraction des mots Window (Fenêtre) et gadget, il peut désigner soit une composant

d’interface graphique tel qu’un bouton, soit un widget interactif : un petit outil qui permet

d’obtenir des informations tel que la météo ou l’actualité.

• XML : Le XML (Extensible Markup Language ou « langage de balisage extensible ») est un

langage informatique de balisage générique. Il sert essentiellement à stocker/transférer des



données de type texte Unicode structuré en champs arborescents. Le World Wide Web

Consortium (W3C), promoteur de standards favorisant l'échange d'informations sur Internet,

recommande la syntaxe XML pour exprimer des langages de balisages spécifiques. De

nombreux langages respectent la syntaxe XML : XHTML, SVG*, XSLT, etc.

Source : wikipedia.org

rapport de projet tutore - j.dul.free.frj.dul.free.fr/jeux/gcompris/rapport_gcompris.pdf ·...

Documents