Labirinto Java - recursividade

Programação Java
#1

Olá, sou nova por aqui, então se estiver fazendo algo errado, já peço desculpas!!

Estou fazendo um trabalho para a faculdade, onde preciso criar um programa que gere um Labirinto (a partir da leitura de um arquivo .txt), e percorre ele procurando a saída - ‘D’.
Acredito que a maior parte do meu código esta correto, ele só não encontra o ‘D’.
Se alguém puder me ajudar a corrigir a lógica para o programa encontrar o ‘D’, eu agradeceria demais.

Segue o codigo, o main e o labirinto.

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class Labirinto {
    
    private char[][] labirinto;

    //inicializa o labirinto vazio
    public Labirinto() {
        labirinto = null;
    }

    // Método para criar o labirinto a partir de um arquivo
    public void criaLabirinto (String filename) throws IOException {
        BufferedReader leitor = new BufferedReader(new FileReader(filename));
        String line;
        int numLinhas = 0;
        int numColunas = 0;

        //Determinar o número de linhas e colunas do labirinto
        while ((line = leitor.readLine()) != null) {
            numLinhas++;
            numColunas = Math.max(numColunas, line.length());
        }

        //Inicializar o labirinto com o tamanho apropriado
        labirinto = new char[numLinhas][numColunas];
        leitor.close();

        //Preencher o labirinto com os dados do arquivo
        leitor = new BufferedReader(new FileReader(filename));
        int linha = 0;

        while ((line = leitor.readLine()) != null) {
            for (int col = 0; col < line.length(); col++){
                labirinto[linha][col] = line.charAt(col);
            }
            linha++;
        }
        leitor.close();
    }

    //Metodo publico para iniciar a busca no labirinto
    public boolean percorreLabirinto() {
        return percorreLabirinto(0, 0);
    }

    //Metodo privado recursivo para buscar a saída do labirinto
    private boolean percorreLabirinto(int linha, int coluna) {

        //verifica se a posicao atual é valida
        if (linha < 0 || linha >= labirinto.length || coluna < 0 || coluna >= labirinto[0].length) {
            return false;
        }

        //marca a posição atual como visitada
        labirinto[linha][coluna] = 'V';

        //verifica se a posição atual é um obstaculo ou ja foi visitada
        if(labirinto[linha][coluna] == 'X' || labirinto[linha][coluna] == 'V') {
            return false;
        }

        //percorre o labirinto
        if (labirinto[linha][coluna] == 'D'){
            System.out.println("Achei a saida em linha " + linha + " coluna: " + coluna );
            return true; // Encontrou a saida, entao retorna verdadeiro
        } 

        //tenta mover para as quatro direções possiveis
        if (percorreLabirinto(linha +1, coluna) || // mover para baixo
            percorreLabirinto(linha -1, coluna) || // mover para cima
            percorreLabirinto(linha, coluna +1) || // mover para direita
            percorreLabirinto(linha, coluna -1)) { // mover para esquerda
                return true;
            }
            
    return false;
    }
        
    //metodo para imprimir o labirinto
    public void imprimirLabirinto() {
        for(int linha = 0; linha < labirinto.length; linha ++) {
            for(int coluna = 0; coluna < labirinto[0].length; coluna++) {
                System.out.print(labirinto[linha][coluna]);
            }
            System.out.println();
        }
    }
}

//Main

import java.io.IOException;

public class Main {
    public static void main(String[] args) {
    Labirinto labirinto = new Labirinto();

        try {
            labirinto.criaLabirinto("labirintoexemplo.txt");
            System.out.println("Labirinto Original: ");
            labirinto.imprimirLabirinto();

            if (labirinto.percorreLabirinto()) {
                System.out.println("Caminho encontrado!");
                System.out.println("Labirinto com o caminho: ");
                labirinto.imprimirLabirinto();
            } else {
            System.out.println("Nenhum caminho encontrado.");
            }
        } catch (IOException e) {
            System.out.println("Erro ao ler o arquivo do labirinto.");
        }
    }
}

//Labirinto
Talvez o labirinto apareça errado na formatação, mas ele tem 8 linhas x 20 colunas

  XXXXXXXXX   XXXXXX
X XXXXXXXXX X   XXXX
X   XXXXXXX XXX XXXX
XXX XXXXXX  XXX XXXX
XXX    XX  XXXX     
XXX XX X  XXXXX XXX 
XXXXXX X XXXXXX   X 
XXXXXX   XXXXXX XXXD
#2

Tens de saber em que posições já passaste senão vais ficar em ciclo infinito de uma para outra e vice versa.

#3

Essa parte do código faz essa verificação, não faz?

Se puder me mostrar como sair desse loop, eu agradeço demais.

#4

É verdade. Mas então o teu problema está exatamente aqui. Marcas a coluna como visitada e depois vais verificar se ja foi visitada (é sempre true) e retornas false.
So podes marcar a coluna para ‘V’ imediatamente antes de verificar os vizinhos, não antes de verificar se tens um X, um V ou um D.