Java droga w labiryncie

Question

Witam. Męczę się kolejne dni ... jak zaimplementować w moim przypadku - tutaj "maze solver" chodzi mi o to, że u mnie program rozwizuję poprawnie- tzn. rysuje ścieżkę i w momencie kliknięcia na przycisk " metoda repaint" nakłada na wygenerowany labirynt sciezke.

Jednak chciałem zaimplementować to tak, aby rysowanie trwało w czasie tzn " krok po kroku" a nie na raz... i nie mam pomysłu, metoda repaint wewnatrz paint, nie działa jeśli dam ją w iteracji. Natomiast działą tylko dla przypadku gdy dam ja w Action listener, ale wtedy generowana jest cała ścieżka.

Wiem, że kod jest- jakościowo słaby, ale to moje 1-wsze projekty, uczę się i rozwijam się. Jeśli ktoś byłby wstanie spojrzeć na kod, ew. coś tutaj wskórać z moim problemem- będę wdzieczny.

tutaj jest sama klasa generujaca przypadkową "tablice 0/1 - reprezentujaca labirynt" 

import java.util.Random;



public class RenderMaze {
    private static int[][] blocks;
    private static boolean[][] visited;
    private static Random rand = new Random();

    public  int[][] generate(int w, int h) {
        int bw = w * 2 + 1;
        int bh = h * 2 + 1;
        blocks = new int[bw][bh];
        visited = new boolean[w + 2][h + 2];
        for(int i = 0; i < blocks.length; i++) for(int j = 0; j < blocks[0].length; j++)
            blocks[i][j] = 1;
        for(int i = 0; i < visited.length; i++) for(int j = 0; j < visited[0].length; j++)
            if(i == 0 || i == visited.length - 1 || j == 0 || j == visited[0].length - 1)
                visited[i][j] = true;

        gen(0, 0);
        //ustawiamy pozycje startowa
        blocks[1][1]=9;
        //pozycja koncowa
        blocks[bw-2][bh-2]=8;
        return blocks;
    }

    private static void gen(int xPos, int yPos) {
        int x = xPos * 2 + 1;
        int y = yPos * 2 + 1;
        blocks[x][y] = 0;
        visited[xPos + 1][yPos + 1] = true;
        while(!visited[xPos][yPos + 1] || !visited[xPos + 2][yPos + 1] || !visited[xPos + 1][yPos + 2] || !visited[xPos + 1][yPos]) {
            float num = rand.nextFloat();
            if(num < 0.25F && !visited[xPos][yPos + 1]) {
                blocks[x - 1][y] = 0;
                gen(xPos - 1, yPos);
            }
            else if(num < 0.5F && num >= 0.25F && !visited[xPos + 2][yPos + 1]) {
                blocks[x + 1][y] = 0;
                gen(xPos + 1, yPos);
            }
            else if(num >= 0.5F && num < 0.75F && !visited[xPos + 1][yPos + 2]) {
                blocks[x][y + 1] = 0;
                gen(xPos, yPos + 1);
            }
            else if(!visited[xPos + 1][yPos]) {
                blocks[x][y - 1] = 0;
                gen(xPos, yPos - 1);
            }
        }
    }
}

tutaj jest cały kontent zarówno rozwiazywania jak i rysowania

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.awt.event.ActionListener;


/**
 * Created by Czowitek on 2017-05-22.
 */
public class RunGui extends JPanel implements ActionListener {

    RenderMaze mazeGen= new  RenderMaze();
    public int WIDTH=10, HEIGHT=10;


    public int wSet= WIDTH*2+1, hSet=HEIGHT*2+1;

    public int arr[][] =  mazeGen.generate(WIDTH,HEIGHT);
    public int solveArr[][]= arr;

    public int  pathMaze[][]= new int[WIDTH*2+1][HEIGHT*2+1];
    public boolean visited[][]=new boolean[WIDTH*2+1][HEIGHT*2+1];
    public static JButton bt1= new JButton("new");


    public static void main(String[] arg ){
        RunGui start= new RunGui();
        JFrame frame= new JFrame("Frame");
        JPanel panel= new JPanel();
        panel.add(start);
        panel.add(bt1);
        frame.add(panel);
        start.setPreferredSize(new Dimension(650, 650));
        start. bt1.addActionListener(start);
        frame.pack();
        frame.setVisible(true);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        System.out.println();
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        if (e.getSource() == bt1) {
            this.solvingProblem();
            }
    }
    public void paint(Graphics g) {
             super.paint(g);
             g.translate(50, 50);

              for (int i = 0; i < arr.length; i++) {
                  for (int j = 0; j < arr[0].length; j++) {
                      Color newColor;
                      switch (arr[i][j]) {
                          case 1:
                              newColor = Color.BLACK;
                              break;
                          case 0:
                              newColor = Color.WHITE;
                              break;
                          case 9:
                              newColor = Color.GREEN;
                              break;
                          case 8:
                              newColor = Color.RED;
                              break;
                          default:
                              newColor = Color.YELLOW;
                      }
                      g.setColor(newColor);
                      g.fillRect(25 * j, 25 * i, 25, 25);
                      g.setColor(Color.black);
                      g.drawRect(25 * j, 25 * i, 25, 25);
                  }
              }
            for (int i = 0; i < wSet; i++) {
                for (int j = 0; j < hSet; j++) {
                    if ( pathMaze[i][j] == 5 && arr[i][j]== 0) {
                        g.setColor(Color.blue);
                        g.fillRect(25 * j+5, 25 * i+5, 15, 15);
                        g.drawRect(25 * j+5, 25 * i+5, 15, 15);
                        repaint();
                    }
                }
            }
    }

    public void solvingProblem() {
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[0].length; j++) {
                pathMaze[i][j] = 1;
                visited[i][j] = false;
            }
        }
        solveMazeInput(1,1);
    }

        public boolean solveMazeInput(int x, int y ){
            if( x ==  wSet-2 && y ==  hSet-2) {
                return true;
            }
            if(solveArr[x][y]== 1 || visited[x][y] ){
                return false;
            }
            visited[x][y]=true;

            if(x!= 0){
                if(solveMazeInput(x-1,y) ) {
                    pathMaze[x][y]= 5;
                    return true;
                }
            }
            if(x != wSet- 1){
                if(solveMazeInput(x+1,y)){
                    pathMaze[x][y]=5;
                    return  true;
                }
            }
            if(y !=0 ){
                if(solveMazeInput(x,y-1)){
                    pathMaze[x][y]=5;
                    return  true;
                }
            }
            if(y != hSet-1 ) {
                if (solveMazeInput(x, y + 1)) {
                    pathMaze[x][y] =5;
                    return true;
                }
            }
            return false;
        }
}