Le rapport du projet tutoré

Transcription

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
SOMMAIRE
Sommaire_______________________________________________________________________ 1
1
2
3
Préambule __________________________________________________________________ 2
1.1
Présentation du travail __________________________________________________________ 2
1.2
Remerciements ________________________________________________________________ 2
Cahier des charges ____________________________________________________________ 3
2.1
Logiciel GCompris ______________________________________________________________ 3
2.2
Environnement et contraintes _____________________________________________________ 3
Etude préalable ______________________________________________________________ 5
3.1
3.1.1
3.1.2
3.1.3
4
Comparatif avec GCompris_______________________________________________________ 6
3.3
Choix de développement ________________________________________________________ 7
3.4
Plannings _____________________________________________________________________ 7
Partie Conception _____________________________________________________________ 9
4.1.1
4.1.2
4.2
4.2.1
4.2.2
4.3
Descriptions techniques _________________________________________________________ 9
Gcompris __________________________________________________________________________ 9
GooCanvas ________________________________________________________________________ 12
Modélisation UML _____________________________________________________________ 12
Digramme de cas d’utilisation __________________________________________________________ 12
Diagramme de séquence _____________________________________________________________ 14
Prototype d’interface ___________________________________________________________ 16
Partie Réalisation ____________________________________________________________ 19
5.1
5.1.1
5.1.2
5.2
5.2.1
5.2.2
5.2.3
6
Logiciel Adibou ______________________________________________________________________ 5
Logiciel Lapin Malin __________________________________________________________________ 5
Logiciel P'tit Bout _____________________________________________________________________ 6
3.2
4.1
5
Etude des logiciels concurrents ____________________________________________________ 5
Module « Apprendre la géographie » _____________________________________________ 19
L’idée ____________________________________________________________________________ 19
Manuel du programme _______________________________________________________________ 20
Insertion & Compilation dans Gcompris ___________________________________________ 24
Compilation de Gcompris à partir du code source __________________________________________ 24
Insertion d’un nouveau module _________________________________________________________ 25
Exemple : Le jeu du Pong _____________________________________________________________ 28
Conclusion _________________________________________________________________ 31
6.1
6.1.1
6.1.2
6.1.3
6.1.4
Difficultés rencontrées __________________________________________________________ 31
Organisation _______________________________________________________________________ 31
Compilation _______________________________________________________________________ 31
Développement ____________________________________________________________________ 32
Formation _________________________________________________________________________ 32
6.2
Bilan ________________________________________________________________________ 32
6.3
Avis du groupe _______________________________________________________________ 33
Glossaire ______________________________________________________________________ 34
BAILLY – FAVERGE – FROUJY – ODUL
Page 1 sur 36
Projet tutore
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.
Page 2 sur 36
Projet tutore
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…
Page 3 sur 36
Projet tutore
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.
Page 4 sur 36
Projet tutore
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…
Page 5 sur 36
Projet tutore
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.
Page 6 sur 36
Projet tutore
-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.
Page 7 sur 36
Projet tutore
FIGURE 1- PLANNING PREVISIONNEL
Après fin du projet, voici le diagramme de Gant que nous pouvons établir :
FIGURE 2 - PLANNING FINAL
Page 8 sur 36
Projet tutore
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.
Page 9 sur 36
Projet tutore
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.
Page 10 sur 36
Projet tutore
FIGURE 4 - ARCHITECTURE DE GCOMP
FIGURE 5 - VUE D'ENSEMBLE DE GCOMPRIS
Sources des schémas : gcompris.net
Page 11 sur 36
Projet tutore
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
Page 12 sur 36
Projet tutore
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
Objectif : Permettre l’utilisation du module Gcompris par l’utilisateur.
Acteur(s) : L’utilisateur final du logiciel.
Pré-conditions : Le module doit être correctement implémenté dans le logiciel Gcompris, et doit être
fonctionnel.
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>
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.
Page 13 sur 36
Projet tutore
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
Objectif : Permettre le réglage de la difficulté du module
Acteur(s) : L’utilisateur / L’administrateur
Pré-conditions : Le module doit être correctement implémenté dans le logiciel Gcompris, et doit être
fonctionnel.
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.
Post-condition : Les objectifs du jeu ne seront pas les mêmes en fonctions de la difficulté choisie.
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
Objectif : Permettre à l’administrateur de choisir les modules voulus et définir le niveau (étoiles) du
jeu
Acteur(s) : L’administrateur
Pré-conditions : Le module doit être correctement implémenté et fonctionnel dans le logiciel Gcompris.
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.
Post-condition : Le jeu est disponible ou non dans le menu des modules proposés
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 :
Page 14 sur 36
Projet tutore
Utilisateur
Module
Gcompris
Carte
Choix du module
Lancement d'une partie
Affichage des niveaux de difficulté
Choix du niveau
Affichage des règles
Interrogation
Affichage question
Réponse
Affichage du score
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.
Page 15 sur 36
Projet tutore
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
Page 16 sur 36
Projet tutore
FIGURE 9 - PROTOTYPE DU MODULE EN NIVEAU FACILE
FIGURE 10 - PROTOTYPE DU MODULE EN NIVEAU DIFFICILE
Page 17 sur 36
Projet tutore
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.
Page 18 sur 36
Projet tutore
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 :
-
5.1
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.
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 :
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 »
Affichage de l’indice sous la carte:
« Paris »
« Londres»
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)
Une fois les dix pays trouvés, on calcule la note de l’utilisateur selon la formule suivante :
Page 19 sur 36
Projet tutore
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
Page 20 sur 36
Projet tutore
−
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.
Page 21 sur 36
Projet tutore
• 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) .
Page 22 sur 36
Projet tutore
FIGURE 11 - EXEMPLE D'UTILISATION
D'UTILISATIO
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
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
calculé de la façon suivante : 1 point par bonne réponse, mais -0.25
0.25 par tentative infructueuse, ce qui
donne un maximum de 10 points (cette méthode de calcul est sujette à modification par la suite).
suite
FIGURE 12 - EXEMPLE D'UTILISATION
ATION 2
Page 23 sur 36
Projet tutore
Finalement, une fois les 10 villes trouvées, on affiche un message de fin, en affichant le score.
FIGURE 13 - FIN DU JEU
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
de texte dynamiquee sur les images, etc. Mais ce programme permet de se faire une idée globale du
projet en cours.
5.2
Insertion & Compilation dans Gcompris
5.2.1
Compilation de Gcompris à partir du code source
La compilation permet de créer le programme à partir du code source. Pour
Pour Gcompris, cette étape
se résume en 3 étapes, voire commandes : sh configure, make et make install.
Nous
ous devons exécuter un script qui va tout d'abord faire des tests sur la machine : c’est la
commande sh configure. Cela va vérifier que toutes les dépendances
dances sont bien installées comme
GooCanvas ou GTK* par exemple.
exemple Si tout est bon, ce script va générer tous les Makefile* pour chaque
module, ainsi qu'un Makefile* pour l'architecture entière de GCompris. Un Makefile* est un fichier qui va
Page 24 sur 36
Projet tutore
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
Page 25 sur 36
Projet tutore
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)
Page 26 sur 36
Projet tutore
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.
Page 27 sur 36
Projet tutore
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.
Page 28 sur 36
Projet tutore
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
Page 29 sur 36
Projet tutore
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.
Page 30 sur 36
Projet tutore
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.
Page 31 sur 36
Projet tutore
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-buttonpress-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.
Page 32 sur 36
Projet tutore
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.
Page 33 sur 36
Projet tutore
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
Page 34 sur 36
Projet tutore
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
Page 35 sur 36

Le rapport du projet tutoré

Transcription

Documents pareils

Quelques ressources et logiciels libres de droits

FdpF2008 v.“3.3” - Fiche de Prep Facile

Adresses utiles Moteurs de recherches www.babygo.fr www

GCompris portable - downloads.tuxfamily.org

les logiciels - IEN Petite-île

TICE libres 2009 - Festival des Petites Lanternes Magiques

Mes logiciels préférés

Manuel Utilisateur de Gcompris

Adrien Bailly - Cerefige

Chevrolet Camaro Members Club de France BULLETIN D`ADHESION