NullPointerException nella generazione di labirinto

package maze;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;

public class Maze {
	
	//Celle:
	//1: muri
	//0: passaggi
		
	private int maze[][];
	private int dim;
	
	Maze(int dim) {
		this.dim = dim;
		maze = generateMaze();
	}
	
	private int[][] generateMaze() {	
		
		int[][] maze = new int[dim][dim];
		
		//Inizializzazione, tutte le celle sono muri (1)
		
		for(int i=0; i<dim; i++) {
			for(int j=0; j<dim; j++) {
				maze[i][j] = 1;
			}
		}
		
		System.out.println("\nPrima stampa\n");
		
		for(int i=0; i<dim; i++) {
			for(int j=0; j<dim; j++) {
				if(maze[i][j] == 0) {
					System.out.print(" ");
				}
				if(maze[i][j] == 1) {
					System.out.print("x ");
				}
			}
			System.out.println();
		}
		
		//Genero due indici random per la casella di partenza
		Random random = new Random();
		
		int r = random.nextInt(dim);
		while(r % 2 == 0) {
			r = random.nextInt(dim);
		}
		
		int c = random.nextInt(dim);
		while(c % 2 == 0) {
			c = random.nextInt(dim);
		}
		
		//Setto la cella di partenza come percorso
		maze[r][c] = 0;
		
		System.out.println("\nSeconda stampa\n");
		
		for(int i=0; i<dim; i++) {
			for(int j=0; j<dim; j++) {
				if(maze[i][j] == 0) {
					System.out.print("o ");
				}
				if(maze[i][j] == 1) {
					System.out.print("x ");
				}
			}
			System.out.println();
		}
		
		//Costruisco il labirinto tramite depth first search 
		recursion(r,c);
		
		return maze;
	}
	
	private void recursion(int r, int c) {
		//Genero 4 direzioni casuali
		Integer[] randDirs = generateRandomDirections();

	     for (int i = 0; i < randDirs.length; i++) { 
	         switch(randDirs[i]){
	         case 1:
	             if (r - 2 <= 0)
	                 continue;
	             if (maze[r - 2][c] != 0) {
	                 maze[r-2][c] = 0;
	                 maze[r-1][c] = 0;
	                 recursion(r - 2, c);
	             }
	             break;
	         case 2: 
	             if (c + 2 >= dim - 1)
	                 continue;
	             if (maze[r][c + 2] != 0) {
	                 maze[r][c + 2] = 0;
	                 maze[r][c + 1] = 0;
	                 recursion(r, c + 2);
	             }
	             break;
	         case 3:
	             if (r + 2 >= dim - 1)
	                 continue;
	             if (maze[r + 2][c] != 0) {
	                 maze[r+2][c] = 0;
	                 maze[r+1][c] = 0;
	                 recursion(r + 2, c);
	             }
	             break;
	         case 4: 
	             if (c - 2 <= 0)
	                 continue;
	             if (maze[r][c - 2] != 0) {
	                 maze[r][c - 2] = 0;
	                 maze[r][c - 1] = 0;
	                 recursion(r, c - 2);
	             }
	             break;
	         }
	     }
	}
	
	private Integer[] generateRandomDirections() {
		ArrayList<Integer> randoms = new ArrayList<Integer>();
		for(int i=0; i<4; i++) {
			randoms.add(i+1);
		}
		Collections.shuffle(randoms);
		return randoms.toArray(new Integer[4]);
	}
	
	public int[][] getMaze() {
		return maze;
	}
}

maze[r][c - 2] = 0;