Université de technologie de Belfort Montbéliard

Concepts fondamentaux en Intelligence Artificielle et langages dédiés.

Responsable de l’UV : M. Lauri Fabrice

2009

Delirium 2 GI01 - Semestre Automne 2009

Coniglio Christophe, De Col Sébastien, Roussel Xavier, Vincent Jeremy

- 2 -

Sommaire

Introduction ....................................................................................................................................... 3

I. Compréhension du sujet ................................................................................................................. 4

1. Fonctionnement du jeu.......................................................................................................... 4

2. Projet...................................................................................................................................... 4

a. Objectif du projet ............................................................................................................... 4

b. Problématiques liées au déplacement du mineur ............................................................. 5

II. Développement du projet .............................................................................................................. 6

1. Algorithme global (réaction du mineur)................................................................................. 6

2. Algorithme de création de carte ............................................................................................ 7

3. Algorithme de l’exploration……………………………………………………………………………………………….8

4. Algorithme a star……………………………………………….. …………………………………………………………….9

III. Détails de l’application................................................................................................................ 10

1. Les cartes du jeu................................................................................................................... 10

2. Avenir de l’application ......................................................................................................... 10

Conclusion........................................................................................................................................ 11

Annexes............................................................................................................................................ 12

- 3 -

Introduction

Dans le cadre de l’UV Concepts fondamentaux en Intelligence Artificielle et

langages dédiés (IA41), la réalisation d’un projet parmi trois nous a été confiée. Nous

avons choisi le jeu Delirium 2, qui nous à paru le plus intéressant. Au sein de ce rapport,

nous allons en détailler la conception.

L’objectif du jeu est le déplacement d’un mineur qui a pour but de rechercher des

diamants dans une carte prédéfinie, tout en évitant les ennemis ou les chutes de pierres.

Une fois le nombre de diamants nécessaires acquis, le mineur a la possibilité de se rendre à

la sortie afin de rejoindre un niveau supérieur.

Le but de ce projet, fut donc de réaliser une intelligence artificielle à implanter à

mineur afin qu’il ait la possibilité de se déplacer seul sans intervention humaine sur la carte

et ainsi, remplir ses objectifs sans se faire tuer.

Nous détaillerons donc dans ce rapport les différentes étapes qui nous ont permis de

mener à bien la réalisation du projet.

- 4 -

I. Compréhension du sujet

1. Fonctionnement du jeu

L’application Delirium 2 est un jeu dans lequel le joueur incarne un mineur évoluant au

sein d’une carte. Ce mineur possède un certain nombre de diamants à trouver dans un

temps imparti. Afin de lui rendre la tache plus compliquée, bon nombre d’ennemis

essayeront de le tuer. Le mineur se déplace dans des cartes plus ou moins complexes,

parfois étant de véritables labyrinthes. Ci-après, une capture du jeu.

Ici, le mineur découvre progressivement la carte en dévorant ses parties inexplorées

afin d’atteindre son objectif.

2. Projet

a. Objectif du projet

L’objectif de ce projet est donc de développer une intelligence artificielle à

implanter au mineur afin que celui-ci puisse terminer les différents niveaux de la partie

sans intervention humaine. Pour ce faire, il a fallu créer différents algorithmes afin de

- 5 -

fournir les données nécessaires à un prédicat déjà existant (move) provoquant le

déplacement du mineur.

b. Problématiques liées au déplacement du mineur

Afin que le mineur puisse mener à bien tous ses objectifs, il a fallu nous pencher

sur différentes problématiques, afin de trouver un moyen de les résoudre. Ainsi, la

première question qui nous est venu à l’esprit fut : « Comment le mineur sait où se

déplacer ». Pour répondre à cela, nous avons envisagé une méthode s’adaptant à toutes les

valeurs prises par le setViewPerimeter.

Nous sous somme alors donné comme objectif que le mineur doit être capable de

finir un maximum de cartes avec un minimum d’informations. L’idéal serait de fixer le

setViewPerimeter à 2 c'est-à-dire que si le mineur est placé au milieu d’une carte il ne voit

que 2 cases autour de lui.

C’est pour cette raison que nous avons concentrer notre travail sur la création d’une

carte à partir des informations données par la fonction move et l’exploration de la carte.

De plus, nous avons travaillé afin que le mineur puisse se déplacer d’un point à un

autre de façon optimal grâce à l’implémentation de l’algorithme astar.

- 6 -

II. Développement du projet

1. Algorithme global (réaction du mineur)

Ci-après, l’algorithme de réaction du mineur. C’est ainsi que le mineur réagira à chaque

instant et après chaque déplacement dans la partie. Cet algorithme régit complètement les

réactions du mineur et c’est en suivant cette démarche qu’il mènera à bien tous ses

objectifs.

Algorithme global

Création de la carte (voir utilité dans le I. 2. B.)

//Permet au mineur d’obtenir une carte complète du monde exploré

SI un chemin de direction est préenregistré dans la liste des coordonnées, ALORS aller au

premier point et le supprimer de la liste.

//Permet au mineur de se déplacer vers la direction souhaitée

SINON SI on a suffisamment de joyaux ET que la sortie a été découverte ALORS

enregistrer les directions pour y aller et se rendre à la première direction et la supprimer de

la liste

//En cas de fin de niveau (tous les joyaux récupérés), on se dirige vers la sortie

SINON SI on n’a pas suffisamment de joyaux et que le plus proche est accessible

ALORS enregistrer les directions pour y aller et se rendre à la première direction et la

supprimer de la liste

//Le mineur recherche dans la carte (créée au début de l’algorithme) les coordonnées du

diamant le plus proche afin de s’y rendre

SINON SI on ne connaît pas les quatre coins de la carte ALORS aller explorer

SINON SI des cases restent inconnues ALORS aller directement les découvrir

//Permet de compléter la carte construite au début de l’algorithme

SINON Explorer aléatoirement la carte (ce cas apparait seulement dans les cas extrême)

//Permet au mineur de ne pas rester inerte. En effet, de la sorte, il continuera à se déplacer.

C’est en nous basant sur cet algorithme de base que nous avons acquis une certaine

compréhension de la démarche à suivre afin que le mineur se déplace judicieusement.

- 7 -

2. Algorithme de création de carte

Le prédicat permettant la création de la carte prend en entrée la liste fournie au départ.

C'est-à-dire, les cases autour du mineur, sa position dans cette liste, la position X et Y, la

carte déjà enregistrée, et le Size qui correspond au nombre de cases en tout sur une ligne.

La fonction enregistre seulement les informations situées à trois cases à gauche et trois

cases à droite du mineur. Par contre en hauteur, toutes les cases situées dans cet intervalle

sont enregistrées.

Cet algorithme retourne ainsi une liste prenant pour valeurs des chiffres correspondant

aux différentes valeurs des obstacles ou objectifs que le mineur rencontrera. (Par exemple

un mur, ou un ennemi, …).

Il faut noter aussi que la fonction stocke sous la valeur -10 les cases qui sont encore

non découvertes.

Par la suite, il sera donc plus aisé de se déplacer fonction de cette liste plutôt que de

travailler ‘’à l’aveugle’’.

En partant du principe que le mineur ne possède pas la totalité de la carte en paramètre,

à chaque déplacement, il continuera d’enregistrer toutes les informations qui lui sont

nécessaires. De ce fait, au fur et à mesure que le mineur se déplace, il aura à sa disposition

une carte constamment mise à jour, ce qui lui permettra d’agir en conséquence.

- 8 -

3. Algorithme de l’exploration

Etant donné que le mineur ne connaît pas la carte il doit commencer par explorer afin

de découvrir l’emplacement des diamants et trouver la sortie.

Pour ceci nous divisons la fonction exploration en 3 parties.

-Tout d’abord nous recherchons les coins inférieurs droits :

Pour ceci nous partons de la case la plus proche du coin inférieur droit et nous utilisons

le astar. Si le astar ne trouve pas de chemin, nous recommençons en supprimant la case

déjà testée, ainsi de suite jusqu’à ce qu’on arrive à la case où est situé le mineur. Si c’est le

cas cela signifie qu’il est en cet instant impossible de découvrir le coin supérieur droit.

-Ensuite nous chercherons le coin inférieur droit :

C’est le même principe que pour le coin supérieur droit mais cette fois, nous

commençons par la case la plus proche du coin inférieur droit.

-Pour finir nous chercherons toutes les cases non explorées :

Ce sont les cases qui ont la valeur -10. A cet instant la fonction qui crée la carte l’a fait

complètement mais avec de nombreuses cases de valeur -10, il reste donc à les explorer.

Pour ceci nous chercherons la case qui a la valeur -10 la plus proche et nous nous y

déplaçons.

- 9 -

4. Algorithme a star

L’algorithme ‘’a star’’ est celui qui nous a permis de créer le déplacement du

mineur. En effet, grâce à cela, nous sommes en mesure de fournir au mineur une

coordonnée précise où se déplacer sur la carte.

Pour ce faire, nous utiliserons deux listes : ‘’ l’open List ’’ et la ‘’closed List’’. Ensuite, on

opère par récurrence sur la variable ayant le plus petit Poids dans l’open List et on la place

dans la closed List jusqu’à ce qu’on tombe sur une variable correspondant aux

coordonnées demandées. Enfin, on remonte les coordonnées à l’envers prises dans la

closed List pour retrouver le chemin complet.

De plus nous avons rajouté des cases spéciales qui augmentent anormalement le poids de la

variable, ce qui permet à cet algorithme d’éviter de faire le tour de cette case mais il

trouvera quand même un chemin si jamais on l’oblige à aller dans ce genre de zone.

Exemple d’une variable (Xp,Yp,X,P,G,H,P)

X, Y correspondent aux coordonnées de la case.

Xp, Yp, coordonnée du père. C'est-à-dire, la case juste avant

P, la distance parcourue par le mineur depuis le point d’origine.

H, l’heuristique. Il correspond à la distance à vol d’oiseau jusqu’à la case ‘’ objectif ’’.

P, le poids qui se calcule ainsi : P=G+H+S, où S représente le poids des cases spéciales.

Généralement S est à 0.

- 10 -

III. Détails de l’application

1. Les cartes du jeu

Afin de mener à bien notre projet, nous avons décidé de créer nous même nos

propres cartes. En effet, les cartes d’origine étant trop complexes, nous avons privilégié le

fait de vouloir montrer les fonctionnalités de notre programme dans un environnement

compatible à ce que nous avons créé.

Ceci nous permet donc de tester de façon optimale notre programme afin d’en

corriger d’éventuelles erreurs. Ceci permet également de montrer les fonctionnalités

acquises pour le mineur, plutôt que de la faire évoluer dans un environnement complexe

dont toutes les fonctions ne sont pas enclines à fonctionner.

2. Avenir de l’application

La solution que nous avons apportée permet déjà de gérer de nombreux cas complexes.

Cependant, de nombreuses améliorations sont encore réalisables. Malheureusement, par

manque de temps, celles-ci n’ont pu être implantées :

-Nous ne gérons que les ennemis statiques, il faudrait l’améliorer en réalisent une fonction

capable d’éviter des ennemis en mouvement

- La gestion des rochers tombants n’est pas optimale. De plus, il n’y a pas d’anticipation

quant à la modification de l’environnement du à la chute de ces pierres.

- 11 -

Conclusion

Ce projet fut très instructif à réaliser. En effet, il nous a permis d’approfondir nos

connaissances en prolog et ainsi, de nous fournir un exemple concret de développement

d’intelligence artificielle.

Il nous a également permis de mettre en application les notions que nous avons

acquises pendant ce semestre. Afin de rendre possible la réalisation du projet, de

nombreuses recherches ont été nécessaires. Ainsi, de nouvelles notions telles que l’étude

de l’algorithme a star nous apporte un véritable plus dans notre parcours futur.

- 12 -

Annexes

Ci-après, quelques situations intéressantes en image.

Il est intéressant de voir qu’ici, le

mineur, après avoir récupéré le

diamant, ne restera pas coincé dans le

mur qui se trouve face à lui. En effet,

ceci est du au fait que notre

algorithme prend en compte le fait de

ne pas repasser deux fois au même

endroit, sans quoi le mineur ne

pourrait se déplacer qu’entre les cases

(8,4) et (8,7).

Dans cette situation, il est intéressant de

constater que malgré le fait que le mineur soit

en mesure de voir les diamants inaccessibles,

il va passer outre afin de se rendre vers le seul

disponible. Ceci évite ainsi qu’il ne soit

bloqué et ne puisse joindre la sortie.

- 13 -

Enfin, tel que nous pouvons le voir ici, dans cette situation, notre programme est capable

de faire un choix quant au choix des

diamants à récolter. En effet, sans ce choix

particulier, le mineur se verrait libérer

certains monstres, et ainsi se faire tuer.

C’est pour cela que cette carte est

intéressante. Non seulement notre

programme va récupérer les diamants

nécessaires pour passer au niveau suivant,

mais de plus, il va éviter de libérer les

ennemis, ainsi que la chute des diamants sur

le mineur.