Bonjour,

Alors voilà mon problème j'ai créé un jeu de tour par tour pour deux joueurs avec Android Studio et avec le package libgdx AI, jusqu'ici j'ai réussi à faire en sorte de bouger mes joueurs.
Le seul problème qui me dérange c'est que l'ennemi qui joue a un "target" (qui est le joueur le plus proche) et j'arrive à le faire bouger jusqu'à son "target" mais lorsqu'il rencontre un obstacle, il ne le contourne pas, j'ai cherché sur internet des algorithmes de pathfinding, mais je n'arrive pas à les appliquer à mon jeu.

Voici les codes de l'ennemi
Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
 
public class Enemy extends Entities {
 
    private static final Logger log = new Logger(Enemy.class.getSimpleName(), Logger.DEBUG);
 
    public Player target;
    public float movement = GameConfig.ENEMY_MOVEMENTS;
 
 
    //Obligatoire pour le JSON
    public Enemy() {
    }
 
    public Enemy(float x, float y, float width, float height,Color color) {
        this.x = x;
        this.y = y;
        this.width = width;
        this.height = height;
        this.color = color;
        target= new Player();
    }
 
    /**
     * Cette méthode vérifie si l'ennemie est en collision avec soit un obstacle(Murs, caisses) ou un joueur
     */
    public boolean isCollidingObstacle(float x, float y, Array<ObstacleBase> obstacles, Array<Enemy> enemies, Player player1, Player player2, int index) {
 
        for (ObstacleBase obstacle : obstacles) {
            if (x >= obstacle.getBounds().getX() && y >= obstacle.getBounds().getY()) {
                if (x <= obstacle.getBounds().getWidth() + obstacle.getBounds().getX() - 1 && y <= obstacle.getBounds().getHeight() + obstacle.getBounds().getY() - 1) {
                    //log.debug("Un obstacle se trouve en " + obstacle.getBounds().getX() + " " + obstacle.getBounds().getY());
                    return true;
                }
            }
        }
 
        int i = 0;
        for (Enemy enemy : enemies) {
 
            if (i == index) {
 
            } else {
                if (x == enemy.getX() && y == enemy.getY()) {
                    return true;
                }
            }
            i++;
        }
        if (x == player1.getX() && y == player1.getY()) {
            return true;
        }
        if (x == player2.getX() && y == player2.getY()) {
            return true;
        }
        return false;
    }
 
    /**
     * Cette méthode permet de vérifier si l'ennemie se trouve à côté de la cible
     * @return
     */
    public boolean nextToTarget(){
        if (x == target.getX()+1 && y == target.getY()||x == target.getX()+1 && y == target.getY()||
                x == target.getX() && y == target.getY()-1||x == target.getX() && y == target.getY()+1) {
            return true;
        }
        return false;
    }
 
    /**
     * Cette méthode permet de savoir quel joueur est le plus proche et de le mettre en target pour l'ennemie
     *
     * @param player1
     * @param player2
     */
    public void nearPlayer(Player player1, Player player2) {
        float diffXP1 = (this.getX() - player1.getX());
        float diffXP2 = (this.getX() - player2.getX());
        float diffYP1 = (this.getY() - player1.getY());
        float diffYP2 = (this.getY() - player2.getY());
 
        if (diffXP1 < 0) {
            diffXP1 *= -1;
        }
        if (diffXP2 < 0) {
            diffXP2 *= -1;
        }
        if (diffYP1 < 0) {
            diffYP1 *= -1;
        }
        if (diffYP2 < 0) {
            diffYP2 *= -1;
        }
        float diffP1=diffYP1-diffXP1;
        float diffP2=diffYP2-diffXP2;
 
        if(diffP1<0){
            diffP1 *= -1;
        }
        if(diffP2<0){
            diffP2 *= -1;
        }
 
        if(diffP1<diffP2){
            target.setX(player1.getX());
            target.setY(player1.getY());
        }else{
            target.setX(player2.getX());
            target.setY(player2.getY());
        }
    }
 
 
    public void update(final Array<ObstacleBase> obstacles, final Array<Enemy> enemies, Player player1, Player player2, int index) {
        move(obstacles, enemies, player1, player2, index);
        nearPlayer(player1,player2);
    }
 
 
    public void move(final Array<ObstacleBase> obstacles, final Array<Enemy> enemies, Player player1, Player player2, int index) {
        if (nextToTarget()) {
            endTurn();
        }else if(!(movements_done==0)&& movement==movements_done){
            endTurn();
        } else if (movement > movements_done || movements_done == 0) {
            if (target.getX() > this.getX()) {
                if (!(isCollidingObstacle(getX() + 1, getY(), obstacles, enemies, player1, player2, index))) {
                    movements_done += 1;
                    setX(getX() + 1);
                }
            } else if (target.getX() < this.getX()) {
                if (!(isCollidingObstacle(getX() - 1, getY(), obstacles, enemies, player1, player2, index))) {
                    movements_done += 1;
                    setX(getX() - 1);
                }
            }
 
            if (target.getY() > this.getY()) {
                if (!(isCollidingObstacle(getX(), getY() + 1, obstacles, enemies, player1, player2, index))) {
                    movements_done += 1;
                    setY(getY() + 1);
                }
            } else if (target.getY() < this.getY()) {
                if (!(isCollidingObstacle(getX(), getY() - 1, obstacles, enemies, player1, player2, index))) {
                    movements_done += 1;
                    setY(getY() - 1);
                }
            }
 
        }
    }
}
Je tiens à précisé que j'ai aussi regardé dans la doc de libgdx AI pour le pathfinding mais même là je ne comprends pas comment l'appliquer au jeu.

Pour plus de précision ou code, je suis à votre disposition.