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

Oui, les graphes c'est juste indispensable en fait. J'ai réussi à faire marcher ton code mais il n'est pas fonctionnel (ou l'inverse). L'algorithme est trop "téméraire", il trace le chemin sans savoir ce qu'il y a vraiment devant lui, donc il a tendance à foncer dans les murs et a plus trop savoir où aller après. Et aussi le fait qu'il teste les différentes directions possible l'une après l'autre, donc en cas d'égalité de distance il en prend une arbitrairement et ça peu donner des trucs assez aberrant. Avec un graphe tu peux lancer un algorithme qui prend en compte l'ensemble de la carte.

Autrement voilà le code corrigé

import java.io.*;
import java.util.Vector;
 
public class Path {
 
        public Node[] startEnd;
        public char[][] map;
        //J'ai viré les deux ArrayList parce que j'ai pas trop compris à quoi elles servaient en fait.
        
        //lecture de la carte et des coordonnées de départ arrivé à partir d'un txt parce que c'est plus pratique, quand même :p
        public Vector<String> lectureMap(String file){
                FileReader fread=null;
                Vector<String> vec=new Vector<String>();
                int c=0;
                int cnt=0;
                String strtmp=new String();
                startEnd=new Node[2];
                try {
                        fread =new FileReader(file);
                } catch (FileNotFoundException e) {
                        System.out.println("Nom de fichier invalide");
                }
                do{
                        try {
                                c= fread.read();
                        } catch (IOException e) {
                                System.out.println("Erreur lors de la lecture");
                        }
                        if((char)c=='\n'){
                                if(cnt<2){
                                        String[] coord=strtmp.split(",");
                                        startEnd[cnt]=new Node(Integer.parseInt(coord[0]),Integer.parseInt(coord[1]));
                                        cnt++;
                                        strtmp=new String();
                                }
                                else{
                                        vec.add(strtmp);
                                        strtmp=new String();
                                }
                        }
                        else{
                                strtmp=strtmp+(char)c;
                        }
                }while(c!=-1);
                strtmp=strtmp.substring(0,strtmp.length()-1);
                        vec.add(strtmp);
                        map= new char[vec.size()-1][];
                        for(int i=0; i<vec.size()-1; i++){
                                map[i]=vec.elementAt(i).toCharArray();
                        }
                show_build(map);
                return vec;
        }
 
        public void calc() {
                try_node(startEnd[0]);
        }
 
        public void try_node(Node n) {
                Node n2 = new Node(-1,-1);
                n2.F=map.length*map[1].length;
                for(int i=1; i<5; i++){
                        /*Là, pour éviter la redondance de code j'ai numéroté les cases adjacentes de 1 à 4 et j'ai bidouiller
                        des formules qui donnent les variations de x et de y en fonction numéro de case, et j'ai fourré le tout
                        dans un "for*/
                        int modX=(i%2)*(int)Math.pow(-1,(-i/3));
                        int modY=((i+1)%2)*(int)Math.pow(-1,(-i/4));
                        System.out.println(passable(n.x+modX,n.y+modY));
                        if (passable(n.x+modX,n.y+modY)) {
                                Node n3 = new Node(n.x+modX,n.y+modY);
                                n3.parent = n;
                                //J'ai viré la distance de AN parce qu'elle faisait faire un peu n'importe quoi. 
                                n3.F = calc_manhatan(n3);
                                if (n2 != null&&n3.F <= n2.F) {
                                        System.out.println("n2:"+i);
                                        n2=n3;
                                }
                        }
                
                if (n2 != null) {
                        if (n2.x==startEnd[1].x&&n2.y==startEnd[1].y) {
                                System.out.println("QSD");
                        }
                        else {
                    map[n2.x][n2.y] = '5';
                                show_build(map);
                    try_node(n2);
                        }
                }
        }
 
        public int calc_manhatan(Node n) {
                return (int) (Math.abs(startEnd[1].x - n.x) + Math.abs(startEnd[1].y - n.y));
        }
 
        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;
        }
 
        public static void main(String[] args) {
            Path p=new Path();
                p.lectureMap("map.txt");
                System.out.println("START");
                        p.calc();
                        show_build(p.map);
        }
 
        public static void show_build(char[][] room) {
            for (int i = 0; i < room.length-1; ++i) {
                System.out.println();
                for (int j = 0; j < room[i].length-1; ++j) {
                    switch (room[i][j]) {
                            case '0':
                                    System.out.print(".");
                                    break;
                            case '1':
                                    System.out.print("O");
                                    break;
                            /*J'ai modifié le code pour le départ (3), pour en retirer la passabilité sinon
                            dans certains cas le chemin peut revenir en arrière.*/
                            case '3':
                                        System.out.print("0");
                                        break;
                            case '2':
                                    System.out.print("#");
                                    break;
                            case '5':
                                    System.out.print("H");
                                    break;
                    }
                }
            }
        }
 
}

Ne pas oublier la deuxième virgule après les coordonnées sinon ça marche pas (je sais pas d'où ça vient)

Pour ce qui est des gros aberrations, voilà celle que j'ai rencontrée:

..........
..........
H0#.......
H##.......
HHHHH##...
....H#O...
..........
..........
..........

..........
..........
H0#.......
H##.......
HHHHH##...
...HH#O...
..........
..........
..........

Sauf que là les deux choix possibles sont à égale distance de la fin, et le code fait que la gauche est prioritaire sur le bas. Donc le chemin fait demi-tour.

..........
..........
H0#.......
H##.......
HHHHH##...
HHHHH#O...
H.........
..........
..........

La même chose se passe sur tout la ligne, jusqu'à ce que le bord vienne bloquer la gauche.