[RPG-MAKER.FR] Oniromancie: tout l'univers de RPG Maker en français

Surement que AStar cherche pas le plus court, mais le chemin le moins coûteux ( Et c'est pas la même chose apparemment )

Je n'y ai réfléchit que très sommairement mais peut-être un truc dans ce genre ferait l'affaire:

-De base, tu traces depuis la porte un chemin de deux cases qui s'éloigne de la salle, et tu appliques l'algorithme sur l'extrémité de ces chemins plutôt que sur les portes.
-L'algo suit l'un des parcours en L d'un point à l'autre (tout horizontal puis tout vertical, ou l'inverse).
-S'il s'approche d'une salle, il la contourne jusqu'à retombe sur un de point d'un des L.

Par contre si on applique ça sur ton deuxième dessins le couloir vert clair va se superposer au vert foncé sur 5 case, je sais pas si ça pose problème?

-Si c'est pour éviter de coller les chemins aux salles, c'est pas graves, j'ai légèrement modifier le truc depuis ( CF plus bas )
-Pour les portes, je pensais plutôt qu'il choisirais le point le plus proche.
( En gros, je prend un mur de ma salle principale, et je trace un cercle autour avec un rayon qui augmente jusqu'à ce qu'il tombe sur une salle "libre". )
Après, oui faire que des chemins en L sera une bonne idée, mais aucune idée de comment le faire xD.

Pour la dernière question, non c'est pas grave, c'est même presque mieux, si possible j'aimerais justement que lorsque deux chemins sont côte à côte, ils se superpose ( Eviter d'avoir des couloirs de deux cases de largeurs donc ).

Zou :

Pour le chemin vert, y a pas de soucis, j'ai modifier légèrement le code, ce qui fait que autour de la salle y a un mur en plus dans lequel les couloirs ne peuvent pas être créé.

Je me doute que ça sera pas possible d'obtenir exactement ça, je voudrais juste avoir quelques choses le plus près de ça possible ^^.

Tassle : C'est ce que me propose Zou ^^.
J'y avais pas pensé, mais c'est une bonne idée, même si j'en suis pas encore là xD.

J'ai trouvé ce tutoriel :
http://www.game-corp.net/article-12-les-algorithmes-de-pathfinding.html

J'ai essayer de le suivre, mais j'arrive à rien :

package mack.pathfinding;
 
import java.util.ArrayList;
 
public class Path {
 
        
        //Mes deux listes
        public ArrayList<Node> open;
        public ArrayList<Node> close;
 
        
        //Mes Nodes de départ et d'arrivé.
        public Node start;
        public Node end;
 
        
        //Ma carte
        public int[][] map;
 
        //Quand je demande de créer un chemin, j'initialise mes variables.
        public Path(Node s, Node e, int[][] m) {
                start = s;
                end = e;
 
                map = m;
 
                close = new ArrayList<Node>();
                open = new ArrayList<Node>();
        }
 
        //Je lance la création en essayant la première case.
        public void calc() {
                try_node(start);
        }
 
        public void try_node(Node n) {
                close.add(n);
                Node n2 = null;
 
                //J'essai sur la case de Droite
                //Si c'est passable
                if (passable(n.x + 1, n.y)) {
                        //Je créer une node, avec les coordonnées testées, et le parent.
                        Node n3 = new Node(n.x + 1, n.y);
                        n3.parent = n;
                        n3.F = calc_F(n3);
                        //Si elle est pas fermé, je l'ajoute dans la liste fermé, et si son F est plus petit que l'ancien
                        //F je remplace n2 par la nouvelle node.
                        //( Ca se voit pas ici puisque de toute façon c'est la première node )
                        if (!contains(n3)) {
                                n2 = n3;
                                close.add(n2);
                        }
                }
 
                //Et je teste comme ça les 4 cases autours.
                if (passable(n.x - 1, n.y)) {
                        Node n3 = new Node(n.x - 1, n.y);
                        n3.parent = n;
                        n3.F = calc_F(n3);
                        if (!contains(n3))
                                if (n2 != null) {
                                        if (n3.F > n2.F) {
                                                n2 = n3;
                                                close.add(n2);
                                        }
                                } else {
                                        n2 = n3;
                                        close.add(n2);
                                }
 
                }
 
                if (passable(n.x, n.y - 1)) {
                        Node n3 = new Node(n.x, n.y - 1);
                        n3.parent = n;
                        n3.F = calc_F(n3);
                        if (!contains(n3))
                                if (n2 != null) {
                                        if (n3.F > n2.F) {
                                                n2 = n3;
                                                close.add(n2);
                                        }
                                } else {
                                        n2 = n3;
                                        close.add(n2);
                                }
                }
 
                if (passable(n.x, n.y + 1)) {
                        Node n3 = new Node(n.x, n.y + 1);
                        n3.parent = n;
                        n3.F = calc_F(n3);
                        if (!contains(n3))
                                if (n2 != null) {
                                        if (n3.F > n2.F) {
                                                n2 = n3;
                                                close.add(n2);
                                        }
                                } else {
                                        n2 = n3;
                                        close.add(n2);
                                }
                }
                if (n2 != null) {
                        if (n2 != end) {
                                map[n2.x][n2.y] = 5;
                                open.add(n2);
                                try_node(n2);
                        } else {
                                System.out.println("QSD");
                        }
                }
 
        }
 
        //Vérifie si une node avec ces coordonnées existe déjà.
        private boolean contains(Node n3) {
                for (int i=0;i<close.size();++i)
                {
                        if (n3.x==close.get(i).x && n3.y==close.get(i).y)
                                return true;
                }
                return false;
        }
 
        //Je calcul le F  de la node
        public int calc_F(Node n) {
                int i = calc_manhatan(n);
                int j = calc_AN(n);
 
                return i + j;
 
        }
 
        //Je calcul la distance de Manhatan
        public int calc_manhatan(Node n) {
                int i = Math.abs(end.x - n.x) + Math.abs(end.y - n.y);
 
                return i;
        }
 
        //Et je calcul la distance AN ( Pas sur de celle là )
        public int calc_AN(Node n) {
                double i = Math.sqrt(Math.pow(start.x - n.x, 2)
                                - Math.pow(start.y - n.y, 2));
 
                return (int) i;
        }
 
        //Permet de savoir si je peux créer un chemin.
        public boolean passable(int i, int j) {
                if (i >= 0 && j >= 0 && i < map.length && j < map[0].length)
                        return map[i][j] == 0 || map[i][j] == 1; 
                return false;
        }
 
        
        //Permet de lancer le programme directement sans passer par le jeu en lui même.
        //Je m'en sert pour faire mes tests avec une map prè-créer.
        public static void main(String[] args) {
                System.out.println("START");
                
                //Ma map test.
                int[][] m = new int[][] { new int[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
                                new int[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
                                new int[] { 0, 1, 2, 0, 0, 0, 0, 0, 0, 0 },
                                new int[] { 0, 2, 2, 0, 0, 0, 0, 0, 0, 0 },
                                new int[] { 0, 0, 0, 0, 0, 2, 2, 0, 0, 0 },
                                new int[] { 0, 0, 0, 0, 0, 2, 1, 0, 0, 0 },
                                new int[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
                                new int[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
                                new int[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
                                new int[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
                                new int[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } };
 
                //J'initialise mes Nodes de départ et d'arrivé.
                Node s = new Node(1, 1);
                Node e = new Node(6, 4);
 
                //J'essaie de créer un chemin.
                Path p = new Path(s, e, m);
 
                p.calc();
 
                //Me permet d'afficher dans la console le résultat.
                show_build(m, m.length, m[0].length);
        }
 
        public static void show_build(int[][] room, int x, int y) {
                for (int i = 0; i < x; ++i) {
                        System.out.println();
                        for (int j = 0; j < y; ++j) {
                                switch (room[i][j]) {
                                case 0:
                                        System.out.print(".");
                                        break;
                                case 1:
                                        System.out.print("O");
                                        break;
                                case 2:
                                        System.out.print("#");
                                        break;
                                case 5:
                                        System.out.print("H");
                                        break;
                                }
                        }
                }
        }
 
}

HHHH....HH
H.HH....HH
HO#H....HH
H##H....HH
HHHH.##.HH
HHHH.#O.HH
HHHH....HH
HHHH....HH
HHHHHHHHHH
HHH......H
HHHHHHHHHH

H c'est mon chemin, O c'est le point de départ et d'arrivé et les # sont les chemins pas traversables.

Et voila la Maj du schéma :

Avec en noir les murs "traversable" par le chemin, en rouge les murs non traversables, en vert le chemin que je souhaiterais avoir, et en bleu celui que j'aimerais éviter.

int r = 16; int d = (int) Math.sqrt(Math.pow(player().x - x, 2) + Math.pow(player().y - y, 2)); double t = angle( new Point(x + d, y), new Point(x, y), new Point(player().x, player().y)); int dx = (int) (x + r * Math.cos(t)); int dy = (int) (y + r * Math.sin(t));