Besoin d'un coup de main - Realisation d'une IA simple

Version imprimable

1 pièce(s) jointe(s)

Bonjour tout le monde ^^
Pour commencer quelques informations:
-La classe mobs récupère correctement les données du joueur.
-La méthode PossibleMove permet de renvoyer un tableau de boolean indiquant si le mob peut ou pas marcher sur les quatre cases autour de lui.
-La méthode NextMove permet de renvoyer un tableau de boolean indiquant laquelle des cases sur lesquelles il peut marcher est choisie pour le prochain mouvement.

Je doit avouer que je suis un peu paumé à force là..

Bref, voici le code de la classe mobs:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
 
package Jeu;
 
import java.awt.Graphics;
 
public class Mobs
{
    private int x, y, xprec, yprec, xbout, ybout, xp, yp;
    private final ImageManager im;
    private final int SPEED = 2;
    public boolean[] bool = new boolean[4];
 
    public Mobs(int x, int y, ImageManager im)
    {
        this.x=x*Game.RESOL*Game.SCALE;
        this.y=y*Game.RESOL*Game.SCALE;
        this.xprec=x;
        this.yprec=y;
        this.im=im;
        this.xp=Game.getP1().getX();
        this.yp=Game.getP1().getY();
    }
 
    public void miseajour()
    {
        bool=NextMove(1);
 
        if(bool[2])
        {
            yprec=y;
            y -= SPEED;
            bool=null;
        }
        else if(bool[3])
        {
            yprec=y;
            y += SPEED;
            bool=null;
        }
        else if(bool[1])
        {
            xprec=x;
            x -= SPEED;
            bool=null;
        }
        else if(bool[0])
        {
            xprec=x;
            x += SPEED;
            bool=null;
        }
 
        xp=Game.getP1().getX();
        yp=Game.getP1().getY();
 
    }
 
 
 
    public void affichage(Graphics g)
    {
        g.drawImage(im.player, x, y, Game.RESOL * Game.SCALE, Game.RESOL * Game.SCALE, null);
    }    
 
    //Methodes pour les monstres "normaux" (tous sauf boss à pattern):
    //
    //      Methode NextMove permettant de renvoyer le prochain mouvement d'un monstre.
    //      Pour ce faire elle doit prendre en argument le type du monstre en question..
    //
 
            public boolean[] NextMove(int typemob)
            {
 
                boolean[] NextMove;               
 
                /*Chargement du tableau des mouvements possibles*/
 
                NextMove=PossibleMove();
 
                /*Fin du chargement du tableau des mouvements possibles*/
 
                switch(typemob)
                {    
 
 
    //                              Pour les monstres "petits" (attaquent uniquement au corps à corps)
 
                    case 1:
 
                            if(NextMove[0]&&xp>x&&x>xprec)
                            {
                                NextMove[1]=false;
                                NextMove[2]=false;
                                NextMove[3]=false;
                            }
                            else if(NextMove[1]&&xp<x&&x<xprec)
                            {
                                NextMove[0]=false;
                                NextMove[2]=false;
                                NextMove[3]=false;
                            }
                            else if(NextMove[2]&&yp>y&&y>yprec)
                            {
                                NextMove[0]=false;
                                NextMove[1]=false;
                                NextMove[3]=false;
                            }
                            else if(NextMove[3]&&yp<y&&y<yprec)
                            {
                                NextMove[0]=false;
                                NextMove[1]=false;
                                NextMove[2]=false;
                            }
                    break;
 
    //                              Pour les monstres "moyens" (attaquent avec des projectiles)
                        /* TODO IA attaque moyen mob */
 
                    case 2:
 
                    break;
 
    //                              Pour les monstres "grands" (Dashent sur le joueur)
                        /* TODO IA attaque grand mob */  
 
                    case 3:
 
                    break;
 
                }
                return NextMove;
            }
 
 
    //
    //      Fin methode "NextMove"
    //
    //      Methode PossibleMove permettant de renvoyer les mouvements possibles.
    //      Cette methode doit pouvoir renvoyer les mouvements possibles d'un mob, pour ce faire elle doit disposer des données concernant le tableau de COLLISION!
    //      Cette methode sera commune à tous les monstres, elle ne sert qu'à décider quelles cases sont possibles, pas à en choisir une.
 
            public boolean[] PossibleMove()
            {
                boolean haut=false;
                boolean bas=false; 
                boolean gauche=false; 
                boolean droite=false;
                MyLevel level=Game.getLevelone();
                if (!level.getTuile(((x-(x%(Game.RESOL*Game.SCALE)))/Game.RESOL/Game.SCALE+1), ((y-(y%(Game.RESOL*Game.SCALE)))/Game.RESOL/Game.SCALE)).collision&&x<level.getW())
                {
                    droite=true;
                }
 
                if (!level.getTuile(((x-(x%(Game.RESOL*Game.SCALE)))/Game.RESOL/Game.SCALE), ((y-(y%(Game.RESOL*Game.SCALE)))/Game.RESOL/Game.SCALE-1)).collision&&y>=0)
                {
                    haut=true;
                }
 
                if (!level.getTuile((x-(x%(Game.RESOL*Game.SCALE)))/Game.RESOL/Game.SCALE-1, (y-(y%(Game.RESOL*Game.SCALE)))/Game.RESOL/Game.SCALE).collision&&x>0)
                {
                    gauche=true;
                }
 
                if (!level.getTuile((x-(x%(Game.RESOL*Game.SCALE)))/Game.RESOL/Game.SCALE, (y-(y%(Game.RESOL*Game.SCALE)))/Game.RESOL/Game.SCALE+1).collision&&y<level.getH())
                {
                    bas=true;
                }
 
                boolean[] PossibleMoves=new boolean[4];
                PossibleMoves[3]=bas;
                PossibleMoves[2]=haut;
                PossibleMoves[1]=gauche;
                PossibleMoves[0]=droite;
 
            return PossibleMoves;
            }
}

Je joins aussi le projet complet (que vous puissiez le consulter au besoin)
Je doit avouer que je ne vois plus où peut-être l'erreur..

Merci d'avance à ceux qui voudront bien me donner un coup de main ^^

05/05/2014, 13h27
PixelJuice

Et euh c'est quoi le soucis / problème en fait?

(utilises les balises [ CODE ] et [ /CODE ] quand tu poste du code)
05/05/2014, 13h30
Rahtys

Me disais bien que j'avais oublié un truc.. x)

Le problème c'est que le mob au lieu de se diriger vers le joueur se dirige invariablement vers le coin haut gauche de l'interface.. ^^'

[EDIT:] Ah je connaissais pas cette balise (j'suis nouveau ici ^^), en effet c'est beaucoup plus propre, merci :)

1 pièce(s) jointe(s)

Bon.. He bien c'est résolu! J'ai réussi à trouver mes erreurs (au final c'était des erreurs d'algo principalement) je colle
ci-dessous la solution trouvée et j'attache une nouvelle version du projet si jamais quelqu'un en a besoin un des ces quatres.. :)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
 
package Jeu;
 
import java.awt.Graphics;
 
public class Mobs
{
    private int x, y, xbout, ybout, xp, yp;
    private final ImageManager im;
    private final int SPEED = 1;
    public boolean haut=false,bas=false,gauche=false,droite=false;
 
    public Mobs(int x, int y, ImageManager im)
    {
        this.x=x*Game.RESOL*Game.SCALE;
        this.y=y*Game.RESOL*Game.SCALE;
        this.im=im;
        this.xp=Game.getP1().getX();
        this.yp=Game.getP1().getY();
    }
 
    public void miseajour()
    {
        NextMove(1);
        if(haut)
        {
            y -= SPEED;
        }
        else if(bas)
        {
            y += SPEED;
        }
        else if(gauche)
        {
            x -= SPEED;
        }
        else if(droite)
        {
            x += SPEED;
        }
        haut=false;
        bas=false;
        gauche=false;
        droite=false;
        xp=Game.getP1().getX();
        yp=Game.getP1().getY();
 
    }
 
 
 
    public void affichage(Graphics g)
    {
        g.drawImage(im.player, x, y, Game.RESOL * Game.SCALE, Game.RESOL * Game.SCALE, null);
    }    
 
    //Methodes pour les monstres "normaux" (tous sauf boss à pattern):
    //
    //      Methode NextMove permettant de renvoyer le prochain mouvement d'un monstre.
    //      Pour ce faire elle doit prendre en argument le type du monstre en question..
    //
 
            public void NextMove(int typemob)
            {             
                PossibleMove();
                switch(typemob)
                {    
 
 
    //                              Pour les monstres "petits" (attaquent uniquement au corps à corps)
 
                    case 1:
 
                            if(droite&&xp>x)
                            {
                                droite=true;
                                gauche=false;
                                bas=false;
                                haut=false;
                            }
 
                            else if(gauche&&xp<x)
                            {
                                droite=false;
                                gauche=true;
                                bas=false;
                                haut=false;
                            }
 
                            else if(bas&&yp>y)
                            {
                                droite=false;
                                gauche=false;
                                bas=true;
                                haut=false;
                            }
 
                            else if(haut&&yp<y)
                            {
                                droite=false;
                                gauche=false;
                                bas=false;
                                haut=true;
                            }
                    break;
 
    //                              Pour les monstres "moyens" (attaquent avec des projectiles)
                        /* TODO IA attaque moyen mob */
 
                    case 2:
 
                    break;
 
    //                              Pour les monstres "grands" (Dashent sur le joueur)
                        /* TODO IA attaque grand mob */  
 
                    case 3:
 
                    break;
 
                }
            }
 
 
    //
    //      Fin methode "NextMove"
    //
    //      Methode PossibleMove permettant de renvoyer les mouvements possibles.
    //      Cette methode doit pouvoir renvoyer les mouvements possibles d'un mob, pour ce faire elle doit disposer des données concernant le tableau de COLLISION!
    //      Cette methode sera commune à tous les monstres, elle ne sert qu'à décider quelles cases sont possibles, pas à en choisir une.
 
            public void PossibleMove()
            {
                MyLevel level=Game.getLevelone();
                if (!level.getTuile(((x-(x%(Game.RESOL*Game.SCALE)))/Game.RESOL/Game.SCALE+1), ((y-(y%(Game.RESOL*Game.SCALE)))/Game.RESOL/Game.SCALE)).collision && !level.getTuile(((x-(x%(Game.RESOL*Game.SCALE)))/Game.RESOL/Game.SCALE+1), ((y-(y%(Game.RESOL*Game.SCALE)))/Game.RESOL/Game.SCALE+1)).collision)
                {
                    droite=true;
                }
 
                if (!level.getTuile(((x-(x%(Game.RESOL*Game.SCALE)))/Game.RESOL/Game.SCALE), ((y-(y%(Game.RESOL*Game.SCALE)))/Game.RESOL/Game.SCALE)).collision  &&  !level.getTuile(((x-(x%(Game.RESOL*Game.SCALE)))/Game.RESOL/Game.SCALE+1), ((y-(y%(Game.RESOL*Game.SCALE)))/Game.RESOL/Game.SCALE)).collision)
                {
                    haut=true;
                }
 
                if (!level.getTuile((x-(x%(Game.RESOL*Game.SCALE)))/Game.RESOL/Game.SCALE, (y-(y%(Game.RESOL*Game.SCALE)))/Game.RESOL/Game.SCALE).collision  &&  !level.getTuile(((x-(x%(Game.RESOL*Game.SCALE)))/Game.RESOL/Game.SCALE), ((y-(y%(Game.RESOL*Game.SCALE)))/Game.RESOL/Game.SCALE+1)).collision)
                {
                    gauche=true;
                }
 
                if (!level.getTuile((x-(x%(Game.RESOL*Game.SCALE)))/Game.RESOL/Game.SCALE, (y-(y%(Game.RESOL*Game.SCALE)))/Game.RESOL/Game.SCALE+1).collision  &&  !level.getTuile(((x-(x%(Game.RESOL*Game.SCALE)))/Game.RESOL/Game.SCALE+1), ((y-(y%(Game.RESOL*Game.SCALE)))/Game.RESOL/Game.SCALE+1)).collision)
                {
                    bas=true;
                }
            }
 
            public void setX(int x) 
            {
                this.x = x;
            }
 
            public void setY(int y) 
            {
                this.y = y;
            }
 
 
}

Pour ceux qui voudraient éventuellement la réutiliser: faites attention un mob utilisant cette IA ne contournera pas les obstacles sur sa route.

Bonne journée/soirée à vous!
Bye :')