Java > checkMap

// Constantes contenant les déplacements possibles.
        // Avantages : je peux facilement switcher entre la possibilité ou non des cases accessibles en diagonales (ici elles le sont) et je peux faire un for dessus.
    private static final int NB_DEP = 8;
    private static final int[][] DEP = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}, {1, 1}, {-1, -1}, {1, -1}, {-1, 1}};

    public void checkMap() {
                // Je crée mon array pour les cases visitées
        boolean[][] visit = new boolean[TAILLE_CARTE][TAILLE_CARTE];
        for(int a=0 ; a<TAILLE_CARTE ; a++)
            for(int b=0 ; b<TAILLE_CARTE ; b++)
                visit[a][b] = false;

                // Tu peux ignorer
        tmpLib = new ArrayList<Case>();
        tmpAll = new ArrayList<Case>();
        tmpAdv = new ArrayList<Case>();

                // Ma case de départ est la case centrale
        checkMap(TAILLE_CARTE / 2, TAILLE_CARTE / 2, visit);

                // Tu peux ignorer
        lib = new Case[tmpLib.size()];
        all = new Case[tmpAll.size()];
        adv = new Case[tmpAdv.size()];

                // Tu peux ignorer
        for(int a=0 ; a<lib.length ; a++)
            lib[a] = tmpLib.get(a);
        for(int a=0 ; a<all.length ; a++)
            all[a] = tmpAll.get(a);
        for(int a=0 ; a<adv.length ; a++)
            adv[a] = tmpAdv.get(a);

                // Tu peux ignorer
        Arrays.sort(lib);
        Arrays.sort(all);
        Arrays.sort(adv);
    }

    public void checkMap(int x, int y, boolean[][] visit) {
                // Je teste si la case est dans les limites de la map
        if(x < 0 || x > TAILLE_CARTE-1 || y < 0 || y > TAILLE_CARTE-1)
            return;

                // Je teste si la case a déjà été visitée pour ne pas tourner en rond
        if(visit[x][y])
            return;
        visit[x][y] = true;

                // La case est valide, donc je la met dans la bonne liste de cases (je maintiens des listes de cases vides / adverses / etc...
                // Tu peux ignorer
        int type = type_case(x, y);
        if(type == VIDE) {
            tmpLib.add(new Case(x, y, valeur_case(x, y)));
            return;
        }
        else if(type == MAISON)
            if(appartenance(x, y) == 0) {
                tmpAll.add(new Case(x, y, valeur_case(x, y)));
                return;
            }
            else {
                tmpAdv.add(new Case(x, y, valeur_case(x, y)));
                return;
            }

                // Si la case n'est pas une route, je ne parcours pas ses fils, c'est inutile dans mon cas. Tu peux ignorer pour le tien
        if(type != ROUTE)
            return;

                // Je lance le parcours des cases adjacentes
        int newX, newY;
        for(int a=0 ; a<NB_DEP ; a++) {
            newX = x+DEP[a][0];
            newY = y+DEP[a][1];
            checkMap(newX, newY, visit);
        }
    }