TER 2010 Réalisation d`un plugin pour la gestion d`équipes et de

TER 2010
Réalisation d'un plugin pour
la gestion d'équipes et de tournois
pour Warbot
Encadrant : Jacques FERBER
FABRE Basile
OLIVIERI Thomas
1/23
BELAMGHARI Aadnan
Table des Matières
Introduction
1. Warbot
1. Présentation
2. Motivation de notre sujet
2. Aspect technique
1. Outils et langages
2. Existant
3. Interface graphique
1. Aspect général
2. Équipe
3. Agents
4. Tournois ?
Génération de code XML
1. XML et Warbot
2. Structure de données
3. Présentation de JDOM
4. Formalisme
Conclusion
2/23
Documentation
1.Webographie
2. Existant
Introduction
Dans le cadre de la première année du Master d'Informatique de la Faculté
des Sciences de Montpellier, nous avons été amenés à réaliser un TER. Le sujet
que nous avons choisis consistait à implémenter un ajout (« plugin» en anglais) au
programme de simulation de combat « Warbot », sujet encadré par M. Ferber.
Ce plugin devait permettre de gérer simplement les différentes équipes de
robots et d'en créer de nouvelles. Il devait également permettre de créer des
tournois, qui sont en fait des enchaînements de cartes. Le but étant de pouvoir
tester simplement une Intelligence Artificielle dans de nombreuses situations
différentes (monde plus ou moins vaste, une carte avec beaucoup de nourriture, un
carte avec beaucoup d'obstacles, une carte avec de nombreux robots, une sans
certains types de robots, etc...). On pourrait ainsi comparer deux Intelligences
Artificielles différentes sur plusieurs types de terrains.
Une autre spécificité du programme était qu'il devait être ouvert à une
éventuelle évolution du logiciel « Warbot », tant en termes d'ajout de nouveaux
types de robots, que d'ajout de nouvelles propriétés pour les robots.
Enfin, il fallait que cet ajout puisse communiquer avec le programme «
Warbot » sans que ce dernier ne subisse de modifications. Pour cela, notre plugin
devait intégrer les informations renseignées par l'utilisateur à travers l'interface, et
générer les fichiers XML correspondants. Ces fichiers n'auraient alors plus qu'à
être lus de manière automatique au lancement de « Warbot ».
Au niveau de la répartition des tâches, après la première réunion avec
l'encadrant de projet M. Ferber, nous avons choisi de commencer par étudier le
3/23
projet existant avant de vraiment diviser les tâches à effectuer. La motivation
initiale ne dura pas et bien que Basile FABRE tenta à plusieurs reprises de
redonner au groupe sa dynamique, il dût travailler seul pendant la durée du
semestre. Le groupe se remis a fonctionner à plein effectif lorsque la date
d'échéance fût trop proche pour être ignorée plus longtemps, mais
malheureusement beaucoup de temps s'était alors écoulé, ne permettant pas à
l'équipe de répondre complètement au sujet.
Warbot
1.Présentation
Notre projet consiste en la réalisation d'un plugin pour le logiciel « Warbot
». Warbot est un jeu mettant en scène deux équipes de robots qui s'affrontent
dans un univers en 2D. Chaque équipe a pour but de détruire la base de
l'adversaire. L'une des particularités de Warbot réside dans le fait que c'est un
jeu pour développeurs : le joueur va programmer l'intelligence de ses robots, mais
il n'aura par la suite aucun autre contrôle sur le jeu. Il ne pourra plus interagir
avec ses robots une fois la partie lancée, et il ne peut en aucun cas modifier les
caractéristiques physiques du robot.
Seule la supériorité dans l'intelligence
artificielle pourra assurer la victoire.
4/23
Warbot
2. Motivation de notre projet
Comme expliqué plus avant dans le rapport, notre projet consistait à réaliser
un plugin pour Warbot afin d'offrir au joueur une interface au travers de laquelle il
serait aisé de créer une équipe et des tournois.
5/23
De nos jours, la procédure est bien plus complexe. Il faut que le joueur
retrouve le fichier appelé « Warbot05.fml », situté dans ./MadKit-4.2.0 / lib /
formalisms. Ce fichier, écrit en XML, contient toutes les équipes déjà présentes,
ainsi que les différents objets du monde (mur, nourriture, etc...). Le joueur doit
alors copier une équipe déjà existante (en modifiant certains paramètres) afin
d'ajouter son équipe à la liste. Il doit également créer un dossier avec le nom de
son équipe dans . / MadKit-4.2.0 / plugins / warbot04 / src / warbot / avec à
l'intérieur les sources Java contenant le code de l'Intelligence Artificielle de ses
robots.
Cette procédure est bien trop lourde pour être compatible avec une
utilisation conviviale du logiciel, et nuit grandement à sa popularité. L'objectif de
notre projet est clair : remplacer cette épreuve purement technique par une simple
étape au travers d'une interface agréable, sinon efficace.
Aspect Technique
1.Outils et langages
Pour ce projet, le langage utilisé fût Java, développé par Sun Microsystems.
C'est un langage orienté objet qui offre une bonne portabilité sur les différents
systèmes d'exploitations pour les programmes. On est ainsi assuré d'avoir le même
6/23
rendu final quelle que soit la machine qui l'exécutera. Le langage est assez proche
de C++, mais il a simplifié certains aspects de la programmation, comme par
exemple les pointeurs, ou l'héritage multiple remplacé par l'implémentation
d'interfaces. En Java, hormis les types primitifs, tout est objet.
L'intérêt d'utiliser ce langage est d'une part la relative simplicité
d'utilisation par le programmeur, et d'autre part l'existence de librairies et de
bibliothèques riches en fonctions et procédures disponibles pour le programmeur.
Par exemple, la très fournie bibliothèque graphique « Swing » permet de créer
simplement des interfaces graphiques riches.
En terme d'outils, la recherche et la documentation furent effectués avec le
navigateur Web Mozilla Firefox. Le code fût écrit avec Eclipse ou Kate (éditeur de
texte adapté à la programmation, et ensuite compilé avec un simple terminal.) selon
les affinités de chacun.
Aspect Technique
2. Existant
7/23
En 2005, une autre équipe d'étudiants avait eu le même sujet. Le résultat
n'ayant pas été concluant (l'application était bien trop complexe et lourde par
rapport aux fonctions demandées), M. Ferber nous a réassigné ce sujet cette
année, et nous a fournis une copie de cet existant, afin de nous en inspirer.
Le programme avait été réalisé par Nicolas MARESCAUX, Laurent
MAJCHER, Hélène MOURET et Ludivine CREPIN. Les instructions étaient
clairement de ne pas chercher à débugger ni à améliorer ce programme, mais de
s'en inspirer pour
en créer un
entièrement
nouveau.
8/23
Aspect Technique
3. Composition de l'application
Le programme a été décomposé en 5 packages afin d'harmoniser son
organisation :
 agents
 data
 gui
 teams
 tournaments
A. Package Agents
Ce package contient les classes nécessaires à la gestion des agents, c.a.d. À
la création, à l'édition et à la suppression. Pour éviter une redondance dans le
code, les classes AgentCreator, AgentEditor et AgentDeletor héritent toutes de la
superclasse AgentFrame.
B. Package Data
Ce package n'est a priori pas vraiment utile mais si l'on songe aux
améliorations pouvant être apportées, nous avons jugé bon de prévoir une telle
éventualité. A l'heure actuelle seule la classe Agent y est présente. Son utilité
étant explicite nous ne la développerons pas ici. Il est utile de préciser que cette
classe définit est à même de définir chacun des types d'agents présents dans
Warbot.
C. Package Gui
Ici se trouve regroupés les classes qui gèrent l'affichage général de
l'application. MainWindow et PopUp crées les fenêtres, ImagePreviewPanel nous
permet d'afficher une miniature de l'image sélectionnée lorsqu'on navigue parmi les
9/23
dossiers pour trouver une icône, et enfin Launcher qui contient exclusivement le
main() pour démarrer l'application.
D. Package Teams
Comme son nom l'indique, ce package contient toutes les classes
nécessaires à la gestion des équipes. Comme pour les classes régissant les Agents,
on a une superclasse TeamFrame qui est héritée par TeamCreator, TeamEditor, et
TeamDeletor. On a en plus une classe AgentInfoPanel qui nous permet d'afficher la
liste des Agents d'une équipe avec plus d'aisance.
E. Package Tournaments
Helas non implémenté à ce jour...
10/23
Interface graphique
1. Aspect général
Le programme se présente sous la forme d'une fenêtre avec un simple
message d'accueil et une image de fond. Un menu en haut a gauche permet de
réaliser diverses actions :
Agents :
Créer un nouveau type d'agents
Teams :
Créer une nouvelle équipe
Éditer une équipe existante
Supprimer une équipe existante
Help :
Le manuel de l'application
A propos
Tournaments :
Lancer un tournoi existant
Créer un nouveau tournoi
Éditer un tournoi existant
Supprimer un tournoi
11/23
Interface graphique
2. Équipe
Dans le menu « Teams », l'utilisateur a le choix entre créer une nouvelle
équipe, modifier une équipe existante, ou en supprimer une. Voici en premier
l'interface de création de l'équipe : elle offre le choix à l'utilisateur de choisir le
nom de son équipe, quels robots il veut dans cette équipe, le nom de chaque type
de robot, et l'icône qui lui sera associé.
12/23
Lorsque l'utilisateur clique sur « Edit », une fenêtre va lui permettre de
configurer l'agent en question, en choisissant son nom, son type parmi la liste des
différents agents disponibles, et enfin son icône.
Lorsque l'utilisateur clique sur « Choose an icon », un navigateur apparaît
pour chercher une icône pour le robot. Ce navigateur inclus une non indispensable
mais ô combien pratique aperçu de l'image.
La
fen
êtr
e
d'é
diti
on
est
trè
s
pro
13/23
che de celle de création, à la différence que l'utilisateur va sélectionner une des
équipes parmi celles existantes grâce à un menu déroulant. On peut
dynamiquement ajouter ou retirer des agents de l'équipe, et éditer ces agents.
L'équipe concerné sera mise à jour dans le fichier XML.
Enfin, le menu de suppression d'équipes est une petite fenêtre qui vous
permet de sélectionner le nom de l'équipe via un menu déroulant parmi celles
présentes dans le fichier
XML.
14/23
Interface graphique
3. Agent
En allant dans le menu Agent de la barre des menus, l'utilisateur a la
possibilité de créer ses propres types de robots en redéfinissant ses composantes.
La suppression d'agents se fait de la même manière que pour les équipes, à
l'aide d'un menu déroulant.
15/23
Interface graphique
4. Tournois
La partie « Tournois » n'a pas été implémentée.
16/23
Génération de code XML
1. XML et Warbot
XML est un langage de balisage très populaire dans le milieu de
l'informatique pour l'échange d'informations entre les autres langages. Supporté
par le World Wide Web Consortium (W3C), il bénéficie de l'avantage que la
plupart des autres langages de programmation ont des fonctions pré-construites
pour convertir des informations en XML, et inversement. Ainsi, dans un soucis de
compatibilité et de facilité d'utilisation, une partie des informations nécessaires au
fonctionnement de « Warbot » sont stockées dans des fichiers XML. Les plugins
ou rajouts à Warbot, qu'ils soient écrits en Java, en Python, ou n'importe quel
autre langage ont aussi leurs informations dans des fichiers XML. Nous avons donc
naturellement choisis de stocker notre équipes et nos agents dans des fichiers
XML.
A chaque interaction entre un fichier XML et l'interface de application, il y a
lecture de l'un, et écriture dans l'autre. La conversion se fait grâce à l'API
(Interface de Programmation Applicative) JDOM disponible gratuitement sur
Internet.
17/23
2. Structure de données
La structure d'un agent Warbot en XML est définie par 5 paramètres
principaux:





son nom
son type
sa taille (radius)
son énergie
son rayon de détection des ennemis
Ces caractéristiques se traduisent en XML par :
<node-desc name="Home" class="warbot.kernel.Home" category="dumb">
<property name="detectingrange">200</property>
<property name="energy">12000</property>
<property name="radius">20</property>
</node-desc>
La structure d'une équipe est définie par des agents qui lui appartiennent.
Chaque agent aura comme caractéristiques :







son nom
son icônes
sa taille (radius)
son équipe
son énergie
son rayon de détection des ennemis
son type de « cerveau » (utilisé pour la programmation de l'IA)
Ces caractéristiques se traduisent en XML par :
<node-desc name="DocExpl" class="warbot.kernel.Explorer" category="DocJLB">
<icon url="images/warbot/docJLB/DocExpl.gif"/>
<property name="radius">12</property>
<property name="team">DocJLB</property>
<property name="detectingrange">130</property>
<property name="energy">1000</property>
<property name="brainClass">warbot.demo.docJLB.DocExplorer</property>
18/23
<graphic-element class="warbot.kernel.GBasicBody">
<property name="imageaddress">images/warbot/docJLB/DocExpl.gif</property>
<property name="labelLocation">4</property>
</graphic-element>
</node-desc>
Génération de code XML
3.Présentation de JDOM
Nous avons utilisé l'API JDom (www.jdom.org) qui permet en quelques lignes
de codes de créer et d'éditer des documents XML à partir de Java. L'exemple de
code qui suit permet de récupérer les données d'un fichier XML pour les traiter, et
enfin actualiser le fichier XML avec les nouvelles données :
// Ouverture du fichier XML
File XMLFile = new File(pathDuFichierXML) ;
SAXBuilder builder = new SAXBuilder(true) ;
Document doc = builder.build(XMLFile) ;
Element root = doc.getRootElement() ;
19/23
//TRAVAIL sur les données dans Java
// ...
// Mise a jour du fichier XML
XMLOutputter serializer = new XMLOutputter(Format.getPrettyFormat()) ;
serializer.output(doc, new FileOutputStream(pathDuFichierXML )) ;
Un autre exemple permet quant à lui de créer des balises, et ainsi former une
hiérarchie telle qu'on peut la trouver au sein du standard XML:
Code Java :
Element action = new Element("action") ;
action.setAttribute("description","userMessage") ;
Element java_method = new Element ("java-method") ;
java_method.setAttribute("name", "showUserMessage") ;
action.addContent(java_method) ;
root.addContent(action) ;
Résultat en XML :
<action description="userMessage">
<java-method name="showUserMessage"/>
</action>*/
Les méthodes les plus compliquées à implémenter furent les méthodes de
recherches dans les fichiers XML. Voici par exemple la méthode qui permet de
créer la liste de toutes les équipes, afin de remplir le menu déroulant du menu de
suppresion d'équipes
// On cree un array « team »
ArrayList<String> teams = new ArrayList<String>();
boolean exists = (new File(MainWindow.teamsFormalism)).exists();
if (exists)
{
// on ouvre le fichier XML et on le lit
File XMLFile = new File(MainWindow.teamsFormalism);
SAXBuilder builder = new SAXBuilder(true);
Document doc = builder.build(XMLFile);
20/23
Element root = doc.getRootElement();
// On récupere toutes les équipes
Element nodeTypes = root.getChild("node-types");
List<Element> nodeDescs = (List<Element>)nodeTypes.getChildren("node-desc");
for (int i = 0; i < nodeDescs.size(); i++)
{
// pour chaque équipe
Element currentDesc = nodeDescs.get(i);
List<Element> properties = currentDesc.getChildren("property") ;
for (int j = 0; j < properties.size(); j++)
{
// on cherche le nom de l'équipe
if(properties.get(j).getAttributeValue("name").equals("team"))
{
if (!teams.contains(properties.get(j).getValue()))
{
// on l'ajoute à l'array « team »
teams.add(properties.get(j).getValue()) ;
}
}
}
}
}
4. Formalisme
Les équipes sont enregistrées dans le fichier Warbot10.fml et les agents dans
robots.fml. Ces deux fichiers XML répondent aux critères définis par le formalisme
« sedit-formalism.dtd ».
Conclusion
erreur
apporté à nous
apporté au programme
21/23
Du point de vue de l'équipe, le projet nous a apporté différentes choses.
Tout d'abord, nous avons appris l'importance de l'implication de soi dès le début
d'un projet : dans le milieu de l'entreprise, nous n'aurons jamais, contrairement à
l'Université, le luxe de pouvoir attendre le dernier moment pour s'impliquer sur un
travail. Sur un autre plan
Enfin, grâce à notre programme, il permettra à toute utilisateur de pouvoir
créer une équipe, voir de nouveau agents à l'aide d'une interface graphique, et
plus en manipulant des fichiers source XML. Nous considérons que c'est un atout
majeur à Warbot pour se faire connaître et apprécier du public, même restreint à la
promotion de l'Université de Montpellier.
Documentation
1. Webographie
22/23
Pour trouver des réponses à nos questions, la principale source
d'informations fût la JavaDoc en ligne fournie par Sun :
http://java.sun.com/j2se/1.4.2/docs/api/
En ce qui concerne XML et donc l'API JDom, nous avons consulté la
documentation officielle (http://www.jdom.org/downloads/docs.html) qui s'est
avérée suffisante.
Il nous est arrivé quelque fois de devoir rechercher sur Internet des
informations plus spécifiques. Nous n'avons pas noter chaque source, mais ce
furent généralement des forums traitant du domaine de l'informatique. Le moteur
de recherche utilisé fût Google.
2. Existant
Nous nous sommes inspirés du projet que nous a remis M. Ferber, projet
réalisé en 2005 par un autre groupe d'étudiant : Nicolas MARESCAUX, Laurent
MAJCHER, Hélène MOURET, Ludivine CREPIN.
23/23