Projet WarBot

Module Systèmes Multi-Agents - Année 2001-2002

Coopération et conflits dans les sociétés d'agents

Proposé par J. Ferber

Contexte

L'étude de la coopération entre agents constitue l'un des aspects les plus importants des systèmes multi-agents. Mais les situations de conflits ou plus exactement de compétition sont au moins aussi importantes que les situations de coopérations.

De nombreux exemples ont été proposés dans l'histoire des systèmes multi-agent pour aider à comprendre et à étudier ces situations: poursuites " proies-prédateurs ", recherche d’échantillons, agence de voyage, robots footballeurs, etc. sont des exemples de telles situations.

Nous nous proposons dans ce module de DEA de vous fournir un nouveau contexte d’étude de la coopération et de la compétition. Ce contexte s’appelle la guerre des robots (Robot War en anglais, dont nous avons tiré le nom du projet WarBot).

Présentation du projet WarBot

Deux équipes comprenant chacune n robots s’affrontent. Ces robots sont divisés en plusieurs catégories : pour l'instant il n'existe que deux types de robots: les robots lanceurs de missiles et les robots eplorateurs.

Le but des équipes est de détruire les bases du camp adverse avant que l'autre ne le fasse...

Pour cela toutes les stratégies sont possibles !

L’objectif de ce projet est de définir une équipe, c’est à dire de définir le comportement des robots sachant que le nombre de robots et leur répartition dans les catégories précitées sont les mêmes pour tous.

Une fois cette équipe définie et les positions initiales précisées, deux équipes s’affrontent sans intervention humaine. Que le meilleur gagne...

Les robots de WarBot

Un robot dans WarBot se compose de deux parties : le corps et la tête.

 

• Le corps définit l’ensemble des caractéristiques " physiques " du robot : ses types d’actions, ses armes, son énergie, etc...
• La tête décrit l’ensemble des comportements du robots, en termes de perception, connaissance, communication avec autrui et prise de décision. (ce sont les systèmes conatifs, représentationnels et communicationnels dans [Fer 95]). C’est la tête des robots qu’il faut très précisément décrire !!

WarBot fonctionne sur la plate-forme MadKit. Il est donc possible d'utiliser tous les outils de cette plateforme pour surveiller l'évolution des robots.

Les types de corps

Dans la version actuelle, il existe exactement trois types de corps de robots:

Les robots explorateurs (warbot.kernel.Explorer)

Ces robots n'ont aucune arme, mais ils se déplacent plus rapidement que les lanceurs de missiles et ils disposent d'une distance de perception plus grande. Voici leurs valeurs initiales (attention la vitesse mesure en fait la "lenteur" des agents. Plus un agent est rapide, plus sa vitesse est faible. Les agents les plus rapides ont une valeur de vitesse de 1):

• Energy: 1000
• DetectionRange: 130
• Speed: 2

Les robots lanceurs de missiles (warbot.kernel.RocketLauncher)

Ces robots sont assez lents, mais disposent d'une bonne quantité d'énergie et surtout sont capables de lancer des rockets. Ils comportent 300 rockets (ce qui est assez importants) et peuvent aussi construire de nouvelles rockets en transformant leur énergie en rockets.

• Energy:
• DetectionRange:
• Speed: 8
• RocketNumber: 300
• Rocket energy cost:

Les bases (warbot.kernel.Home)

Les bases sont aussi des robots, mais des robots immobiles. Elles disposent d'une grande énergie initiale, d'une grande capacité de perception et de toutes les caractéristiques de communication des autres robots.

• Energy: 12000
• DetectionRange: 200
• Speed: 0

Les têtes (brain)

Les têtes sont des agents madkit qui contrôlent le comportement des "corps" des robots. La classe madkit.kernel.Brain constitue le lieu de relation entre les programmes comportementaux des têtes et les comportements effectifs réalisés par le corps.

On peut programmer les têtes pour l'instant dans trois langages différents: Java, Python et Jess.

Python et Jess sont des langages de scripting qui permettent de décrire des comportements d'agents de manière très facile.

Python est un langage fonctionnel et objet qui manipule de manière très élégante des structures de données telles que les listes et les dictionnaires. De plus la version de Python utilisée, jython disponible sur le site www.jython.org, permet d'utiliser toutes les classes Java.

Jess un système à base de règles qui fonctionne selon le modèle des "moteurs d'inférence": un ensemble de règle s'appliquent sur une base de faits jusqu'à ce que la base soit saturée, c'est à dire que le moteur ne puisse plus déduire de nouveaux faits. Jess, qui est un moteur d'inférence fonctionnant essentiellement en chaînage avant, implémente l'algorithme de Rete. C'est un descendand de OPS5 et CLIPS. Il est très pratique pour décrire des comportements d'agents évolués, en associant un comportement élémentaire à une règle. Il est possible aussi d'ajouter des fonctions et ainsi d'étendre les capacités du langage. Jess est très bien interfacé à Java. Toutes les classes de Java sont directement accessibles depuis Jess.

Par la suite d'autres langages de scripting seront disponibles: Scheme (version Kawa), Forth (Fidji), BeanShell (un interpréteur Java), JavaScript, etc...

Quelques exemples

• Voici un exemple de " tête" de robot écrit en Java. Ce robot présente un comportement de "fourmi" (très élémentaire): il cherche de la nourriture qu'il mange s'il en trouve, et il rebondit sur les obstacles.
• Voici un autre exemple de tête de robot écrit en Python. Ce robot présente exactement le même comportement que le précédent. Seul le langage de description des comportements diffère.
• Idem pour un comportement de RocketLauncher un peu bête qui tire sur tous les ennemis sans trop réfléchir.
• Un comportement d'explorateur écrit en Python. Ce robot envoie à tous les "launcher" de son groupe la position de la base s'il la trouve.
• Un comportement de RocketLauncher associé au précédent. Lorsqu'il reçoit un message indiquant une position de la base, il fonce dans la direction.

On pourra note d'une part la simplicité des comportements, et d'autre part que le comportement d'équipe est très réduit (sinon inexistant) dans ces exemples. A vous de jouer...

Les actions des corps

Voici quelques unes des actions et fonctions primitives que l'on peut utiliser pour programmer des "têtes" (on appelle "Brain" en anglais ces têtes). Toutes ces fonctions se présentent comme des méthodes "public" de la classe warbot.kernel.Brain:

Actions d'accès aux attributs internes du robot

• int getEnergy() : retourne l'énergie courante d'un robot. Lorsque cette énergie est égale à zéro, le robot meurt...
• int getMaximumEnergy(): retourne l'énergie maximum qu'un robot peut normalement posséder
• double getHeading(): retourne la direction (en degrés) que le robot prend.
• String getTeam(): retourne la chaîne de caractère décrivant l'équipe du robot (la plupart du temps l'une des valeurs "green" ou "red".
• int getX(): retourne la coordonnée en x de la position courante (en entier)
• int getY(): retourne la coordonnée en x de la position courante (en entier)

Actions de déplacement

• void setHeading(double dir) : définit la direction à prendre (en degrés). Les directions sont données dans le sens classique en navigation (sens des aiguilles d'une montre, inverse du sens trigonométrique). Le 0 se situe vers la droite.
• void move() : avance dans la direction courante.
• boolean isMoving(): indique si l'agent s'est déplacé lors de l'action précédente. Permet de savoir si un agent est bloqué par un obstacle.
• double towards(double a, double b) : retourne la direction qu'il faut prendre pour aller dans la direction où se trouve le point de coordonnées a et b. Les valeurs de ces coordonnées sont relatives au robot.
• double towardsAbsolute(double x, double y): retourne la direction qu'il faut prendre pour aller dans la direction où se trouve le point de coordonnées a et b. Les valeurs de ces coordonnées sont relatives au robot.
• double distanceTo(Percept p) : retourne la distance,
• double distanceToAbsolute(double x, double y): retourne la distance qui sépare le robot des coordonnées x et y données en absolu.
• void randomHeading() : pointe dans une direction aléatoire.

Actions de détection

• Percept[] getPercepts() : retourne l'ensemble des percepts issus des entités qui se trouvent dans la portée de détection du robot.
• boolean getShot(): indique si l'agent vient d'être touché par une rocket.

Actions de communication

Toutes les communications entre agents (donc entre 'Brains') s'effectuent à l'aide de message de type "WarbotMessage" qui ne comprennent que des chaînes de caractères: il est donc impossible de transférer une référence vers un objet à l'aide d'un message.

• WarbotMessage readMessage() : retourne le premier message de la boîte aux lettres si la boite aux messages n'est pas vide et l'enlève de la boîte aux lettres. Retourne null si la boîte est vide.
• boolean isMessageBoxEmpty(): indique si la boîte de message est vide.
• int getMessageBoxNumber(): retourne le nombre de messages dans la boîte aux lettres.
• void send(AgentAdress agent, String act): envoie un message de performatif act à l'agent agent (qui est généralement un Brain).
• void send(AgentAdress agent, String act, String arg): envoie un message de performatif act et d'argument arg à l'agent agent (qui est généralement un Brain).
• void send(AgentAdress agent, String act, String arg1, String arg2): envoie un message de performatif act et d'argument arg1 et arg2 à l'agent agent (qui est généralement un Brain).
• void send(AgentAdress agent, String act, String[] cont): envoie un message de performatif act et et de tableau d'argument cont à l'agent agent (qui est généralement un Brain).
• void broadcast(String group, String role, String act): envoie un message de performatif act à tous les agents jouant le rôle role dans le groupe group.
• void broadcast(String group, String role, String act, String arg): envoie un message de performatif act et l'argument arg à tous les agents jouant le rôle role dans le groupe group.
• void broadcast(String group, String role, String act, String arg1, String arg2): envoie un message de performatif act et l'argument arg1 et arg2 à tous les agents jouant le rôle role dans le groupe group.
• void broadcast(String group, String role, String act, String[] cont): envoie un message de performatif act et de tableau d'argument cont à tous les agents jouant le rôle role dans le groupe group.

Il est possible d'obtenir les informations correspondant à un WarbotMessage de la manière suivante:

• AgentAdress getSender():
• String getAct():
• String getArg1():
• String getArg2():
• String getArgN(int i):
• String[] getContent():
• int getNumberArgs():

Attention: un 'Brain' ne peut pas envoyer d'autres messages que des WarbotMessage. Même les mécanismes d'envoi de messages traditionnels (sendMessage, broadcastMessage, etc..) ont été réécrits pour ne pas permettre de manipuler d'autres types de messages.

Actions de manipulation d'objets

• boolean eat(Food e) : tente de manger l'entité e (si elle est comestible, sinon il ne se passe rien). Retourne le succès de l'action.
• boolean take(Percept e) : tente de prendre une entité courante. Retourne le succès de l'action. Pour l'instant, on ne peut prendre que de la nourriture (percept Food qui représente un Hamburger).
• boolean drop(int i) : dépose la ième entité disponible dans le sac du robot.
• Percept[] inMyBag(): retourne l'ensemble des objets que le robot possède sous la forme d'un ensemble de percepts. Evidemment, les informations de position ne sont pas très pertinentes.
• boolean isMyBagFull() : indique si le sac est plein.
• boolean isMyBagEmpty(): indique si le sac est vide.
• int nbOfObjectsInMyBag() : retourne le nombre d'objets que le robot porte dans son sac.

Note: pour l'instant les commandes de manipulation de sac ne sont pas terminées... Cela ne devrait pas durer...

Actions de commandes des armes (uniquement valables pour les RocketLauncher)

• void launchRocket(double dir) : tire une rocket dans la direction indiquée. Attention, on ne peut tirer qu'une seule rocket toutes les 3 unités de temps seulement. Il faut un peu de temps pour recharger ;-)
• int getRocketNumber(): retourne le nombre de rocket dont dispose le robot
• void buildRocket(): crée une rocket.

Evidemment, d’autres actions sont envisagées et seront fournies par la suite. Pour plus d’informations retourner régulièrement à cette page à l’adresse www.lirmm.fr/~ferber/warbot

De plus, comme les têtes sont des AbstractAgent au sens de MadKit, ils disposent de toutes les fonctionnalités des agents MadKit!! (création de groupes, demande d'adhésion à un groupe en jouant un rôle, récupération de tous les agents jouant un certain rôle dans un certain groupe, etc..)

Pour plus d'informations et de détails, lire la Javadoc du dossier WarBot, le code sources des corps et des têtes données en exemple.

Bibliographie

[Fer 95] J. Ferber, les systèmes multi-agents, InterEditions, 1995.