Buenas tengo un problema de compilación en mi trabajo y no se resolverlo, agradeceria ayuda para poder resolverlo. Gracias de antemano.

Creo que el problema esta con la funcion esta vacia.

Este es el error:
Exception in thread "main" 9 java.lang.NullPointerException
 at juego.textui.AtariGo.pintarFilas(AtariGo.java:205)
 at juego.textui.AtariGo.mostrarTablero(AtariGo.java:191)
 at juego.textui.AtariGo.main(AtariGo.java:49)

AtariGo.java

package juego.textui;
 
import java.util.Scanner;
 
import juego.control.ArbitroAtariGo;
import juego.control.ConfiguracionAtariGo;
import juego.modelo.Celda;
import juego.modelo.Color;
import juego.modelo.Jugador;
import juego.modelo.Tablero;
import juego.util.ConversorJugada;
 
/**
 * Juego del AtariGo.
 * Metodologia de la Programacion.
 * 2� ITIG - Curso 2017-2018. Interfaz en modo texto del juego.
 * 
 * @author 
 * @version 1.0
 * 
 */
public class AtariGo {
 
	/** Tamaño. */
	private static int tamaño;
 
	/** Arbitro. */
	private static ArbitroAtariGo arbitro;
 
	/**
	 * Flujo de ejecución principal del juego.
	 * 
	 * @param args
	 *            nombres de los jugadores y tamaño del tablero
	 */
	public static void main(String[] args) {
		/* Nota:
		 * 
		 * A COMPLETAR REUTILIZANDO LOS
		 * MÉTODOS DISPONIBLES EN EL RESTO DEL CÓDIGO
		 * NO MODIFICAR LOS MÉTODOS PRIVADOS DADOS. 
		 */ 
		Scanner scanner = new Scanner(System.in); //Para recoger datos de teclado
		Celda celda = new Celda(0,0);
		if(sonArgumentosValidos(args)==false) {
			mostrarAyuda();
		}else {
		inicializarConArgumentos(args);
		while(arbitro.estaAcabado()==false) {
			mostrarTablero(arbitro.obtenerTablero());
			mostrarPrompt();
			celda=introducirCelda(scanner, arbitro.obtenerTablero());
			if(celda.estaVacia()==true) {
				realizarJugadaSiEsValida(celda);
			}else {System.err.println("Celda ya ocupada");
			}
		}
		mostrarResultadoFinalPartida(arbitro);
		}
		scanner.close();
	}
 
 
	/**
	 * Realiza la jugada si es valida, mostrando un error en caso contario.
	 * 
	 * @param celda
	 *            celda
	 */
	private static void realizarJugadaSiEsValida(Celda celda) {
		if (celda != null && arbitro.esMovimientoLegal(celda)) {
			arbitro.jugar(celda);
		} else {
			mostarMensajeMovimientoIncorrecto();
		}
	}
 
	/**
	 * Lee la entrada del usuario traduciéndola a la celda correspondiente.
	 * 
	 * @param scanner
	 *            scanner
	 * @param tablero
	 *            tablero
	 * @return celda correspondiente o null en caso de no existir equivalencia
	 */
	private static Celda introducirCelda(Scanner scanner, Tablero tablero) {
		String entrada;
		entrada = scanner.next().toUpperCase();
		return  ConversorJugada.convertir(entrada, tablero);
	}
 
	/**
	 * Muestra la información sobre un movimiento incorrecto.
	 */
	private static void mostarMensajeMovimientoIncorrecto() {
		System.err.print("Movimiento incorrecto.\n" + " Compruebe sintaxis y semántica de la jugada "
				+ " (no se puede colocar en celda ocupada ni se permiten suicidios).");
	}
 
	/**
	 * Mustra el prompt del juego para introducir datos desde teclado.
	 * 
	 */
	private static void mostrarPrompt() {
		System.out.println();
		System.out.printf("El turno es de: %s con piedras %c de color %s%n",
				arbitro.obtenerJugadorConTurno().obtenerNombre(),
				arbitro.obtenerJugadorConTurno().obtenerColor().toChar(),
				arbitro.obtenerJugadorConTurno().obtenerColor());
		System.out.print("Introduce jugada: ");
	}
 
	/**
	 * Muestra el resultado final de la partida.
	 * 
	 * @param arbitro
	 *            arbitro
	 */
	private static void mostrarResultadoFinalPartida(ArbitroAtariGo arbitro) {
		mostrarTablero(arbitro.obtenerTablero());
		System.out.println();
		Jugador jugador = arbitro.obtenerGanador();
		System.out.println("El ganador es " + jugador.obtenerNombre());
	}
 
	/**
	 * Valida los argumentos del juego introducidos por teclado.
	 * 
	 * @param args
	 *            argumentos
	 * @return true si son correctos, false en caso contario
	 */
	private static boolean sonArgumentosValidos(String[] args) {
		boolean validacion = true;
		if (args.length != 0 && args.length != 3) {
			validacion = false;
		} else if (args.length == 3) {
			// Validacion de tamaños de teclado.
			tamaño = Integer.parseInt(args[2]);
			if (!ConfiguracionAtariGo.esTamañoValido(tamaño)) {
				validacion = false;
			}
		}
		return validacion;
	}
 
	/**
	 * Inicializa los elementos del juego. Se supone que los argumentos han sido
	 * validados previamente.
	 * 
	 * @param args
	 *            argumentos válidos
	 */
	private static void inicializarConArgumentos(String[] args) {
		assert sonArgumentosValidos(args);
		String jugador1;
		String jugador2;
		if (args.length == 0) {
			// Valores por defecto
			tamaño = ConfiguracionAtariGo.TAMAÑO_POR_DEFECTO;
			jugador1 = "Abel";
			jugador2 = "Caín";
		} else {
			tamaño = Integer.parseInt(args[2]);
			jugador1 = args[0];
			jugador2 = args[1];
		}		
		inicializarArbitro(jugador1, jugador2, tamaño);
	}
 
	/**
	 * Inicializa el árbitro.
	 * 
	 * @param jugador1 jugador1
	 * @param jugador2 jugador2
	 * @param tamaño tamaño
	 */
	private static void inicializarArbitro(String jugador1, String jugador2, int tamaño) {
		Tablero tablero = new Tablero(tamaño, tamaño);
		arbitro = new ArbitroAtariGo(tablero);
		arbitro.registrarJugadoresEnOrden(jugador1);
		arbitro.registrarJugadoresEnOrden(jugador2);
	}
 
	/**
	 * Muestra la ayuda en línea para la inicialización correcta del juego.
	 */
	private static void mostrarAyuda() {
		System.out.println("Juego del AtariGo");
		System.out.println();
		System.out.println("Uso1: java juego.textui.AtariGo nombreJugador1 nombreJugador2 tamaño");
		System.out.println("Uso2 (valores por defecto): java juego.textui.AtariGo");
		System.err.println("Tamaño debe ser uno de los permitidos en la configuración del juego."
				+ ConfiguracionAtariGo.generarAyuda());
	}
 
	/**
	 * Muestra el estado actual del tablero.
	 * 
	 * @param tablero
	 *            tablero a pintar en pantalla.
	 */
	private static void mostrarTablero(Tablero tablero) {
		pintarFilas(tablero);
		pintarLetrasEnLineaInferior(tablero);
	}
 
 
	/**
	 * Pinta las filas con el número correspondiente y las piedras en cada fila.
	 * 
	 * @param tablero
	 *            tablero
	 */
	private static void pintarFilas(Tablero tablero) {
		System.out.println();
		for (int i = 0; i < tablero.obtenerNumeroFilas(); i++) {
			System.out.print((tablero.obtenerNumeroFilas() - i) + "\t");
			for (int j = 0; j < tablero.obtenerNumeroColumnas(); j++) {
				Celda celda = tablero.obtenerCelda(i, j);
				if (celda.estaVacia()) {
					System.out.print(" - ");
				} else {
					Color color = celda.obtenerColorDePiedra();
					System.out.printf(" %s ", color.toChar());
				}
			}
			System.out.println();
		}
	}
 
	/**
	 * Pinta la fila inferior con las letras.
	 * 
	 * @param tablero
	 *            tablero
	 */
	private static void pintarLetrasEnLineaInferior(Tablero tablero) {
		System.out.println();
		System.out.print("\t");
		for (int i = 0; i < tablero.obtenerNumeroColumnas() + 1; i++) {
			char letra = (char) (i + 'A');
			if (letra != ConfiguracionAtariGo.LETRA_NO_UTILIZADA) {
				System.out.print(" " + letra + " ");
			}
		}
		System.out.println();
	}
}

package juego.modelo;
 
/**
 * Clase celda
 * Metodologia de la Programacion.
 * 2� ITIG - Curso 2017-2018. 
 * Interfaz en modo texto del juego.
 * 
 * @author Pablo Seoane Fuente y Sergio Ruiz Orodea
 * @version 1.0
 * 
 */
public class Celda {
 
	private int fila;
	private int columna;
	private Piedra piedra;
 
	/**
	 * Constructor de Celda
	 * 
	 * @param fila
	 *            Fila de celda
	 * @param columna
	 *            Columna de la celda
	 */
	public Celda(int fila, int columna) {
		this.columna = columna;
		this.fila = fila;
	}
 
	/**
	 * Devuelve la piedra asignada a la celda
	 * @return
	 */
	public Piedra obtenerPiedra() {
		return this.piedra;
	}
 
	/**
	 * Devuelve el color de la piedra
	 * @return
	 */
	public Color obtenerColorDePiedra() {
		return this.piedra.obtenerColor();
	}
 
	/**
	 * Establecer la piedra
	 * 
	 * @param piedra
	 * 			Piedra a establecer
	 */
	public void establecerPiedra(Piedra piedra) {
		this.piedra = piedra;
	}
 
	 /**
	  * Devuelve si la celda esta vacia
	  * @return Boolean indicado si esta vacia
	  */
	public boolean estaVacia() {
		return obtenerPiedra() == null;
 
	}
 
	/**
	 * Devuleve la fila de la celda
	 * @return
	 */
	public int obtenerFila() {
		return this.fila;
	}
 
	/**
	 * Devuelve la columna de la celda
	 * @return
	 */
	public int obtenerColumna() {
		return this.columna;
	}
 
	/**
	 * Comprueba iguales coordenadas
	 * @return
	 */
	public boolean tieneIgualesCoordenadas(Celda celda2){
		return this.obtenerFila() == celda2.obtenerFila() && this.obtenerColumna() == celda2.obtenerColumna(); 
	}
	/**
	 * Comprueba iguales coordenadas
	 * @return
	 */
	public void eliminarPiedra(){
		this.piedra = null;
	}
 
	/**
	 * Sobrescribir el metodo toString
	 */
	public String toString() {
		return "Celda[Fila: " +obtenerFila()+ ", Columna: " +obtenerColumna()+ " y Piedra: " +obtenerPiedra()+ "]";
	}
 
}