elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Introducción a Git (Primera Parte)


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación General
| | |-+  Java
| | | |-+  AYUDA urgente entrega de trabajo en 1 hora
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: AYUDA urgente entrega de trabajo en 1 hora  (Leído 1,170 veces)
MancoJava

Desconectado Desconectado

Mensajes: 1


Ver Perfil
AYUDA urgente entrega de trabajo en 1 hora
« en: 17 Noviembre 2017, 22:03 pm »

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
Código
  1. package juego.textui;
  2.  
  3. import java.util.Scanner;
  4.  
  5. import juego.control.ArbitroAtariGo;
  6. import juego.control.ConfiguracionAtariGo;
  7. import juego.modelo.Celda;
  8. import juego.modelo.Color;
  9. import juego.modelo.Jugador;
  10. import juego.modelo.Tablero;
  11. import juego.util.ConversorJugada;
  12.  
  13. /**
  14.  * Juego del AtariGo.
  15.  * Metodologia de la Programacion.
  16.  * 2� ITIG - Curso 2017-2018. Interfaz en modo texto del juego.
  17.  *
  18.  * @author
  19.  * @version 1.0
  20.  *
  21.  */
  22. public class AtariGo {
  23.  
  24. /** Tamaño. */
  25. private static int tamaño;
  26.  
  27. /** Arbitro. */
  28. private static ArbitroAtariGo arbitro;
  29.  
  30. /**
  31. * Flujo de ejecución principal del juego.
  32. *
  33. * @param args
  34. *            nombres de los jugadores y tamaño del tablero
  35. */
  36. public static void main(String[] args) {
  37. /* Nota:
  38. *
  39. * A COMPLETAR REUTILIZANDO LOS
  40. * MÉTODOS DISPONIBLES EN EL RESTO DEL CÓDIGO
  41. * NO MODIFICAR LOS MÉTODOS PRIVADOS DADOS.
  42. */
  43. Scanner scanner = new Scanner(System.in); //Para recoger datos de teclado
  44. Celda celda = new Celda(0,0);
  45. if(sonArgumentosValidos(args)==false) {
  46. mostrarAyuda();
  47. }else {
  48. inicializarConArgumentos(args);
  49. while(arbitro.estaAcabado()==false) {
  50. mostrarTablero(arbitro.obtenerTablero());
  51. mostrarPrompt();
  52. celda=introducirCelda(scanner, arbitro.obtenerTablero());
  53. if(celda.estaVacia()==true) {
  54. realizarJugadaSiEsValida(celda);
  55. }else {System.err.println("Celda ya ocupada");
  56. }
  57. }
  58. mostrarResultadoFinalPartida(arbitro);
  59. }
  60. scanner.close();
  61. }
  62.  
  63.  
  64. /**
  65. * Realiza la jugada si es valida, mostrando un error en caso contario.
  66. *
  67. * @param celda
  68. *            celda
  69. */
  70. private static void realizarJugadaSiEsValida(Celda celda) {
  71. if (celda != null && arbitro.esMovimientoLegal(celda)) {
  72. arbitro.jugar(celda);
  73. } else {
  74. mostarMensajeMovimientoIncorrecto();
  75. }
  76. }
  77.  
  78. /**
  79. * Lee la entrada del usuario traduciéndola a la celda correspondiente.
  80. *
  81. * @param scanner
  82. *            scanner
  83. * @param tablero
  84. *            tablero
  85. * @return celda correspondiente o null en caso de no existir equivalencia
  86. */
  87. private static Celda introducirCelda(Scanner scanner, Tablero tablero) {
  88. String entrada;
  89. entrada = scanner.next().toUpperCase();
  90. return  ConversorJugada.convertir(entrada, tablero);
  91. }
  92.  
  93. /**
  94. * Muestra la información sobre un movimiento incorrecto.
  95. */
  96. private static void mostarMensajeMovimientoIncorrecto() {
  97. System.err.print("Movimiento incorrecto.\n" + " Compruebe sintaxis y semántica de la jugada "
  98. + " (no se puede colocar en celda ocupada ni se permiten suicidios).");
  99. }
  100.  
  101. /**
  102. * Mustra el prompt del juego para introducir datos desde teclado.
  103. *
  104. */
  105. private static void mostrarPrompt() {
  106. System.out.println();
  107. System.out.printf("El turno es de: %s con piedras %c de color %s%n",
  108. arbitro.obtenerJugadorConTurno().obtenerNombre(),
  109. arbitro.obtenerJugadorConTurno().obtenerColor().toChar(),
  110. arbitro.obtenerJugadorConTurno().obtenerColor());
  111. System.out.print("Introduce jugada: ");
  112. }
  113.  
  114. /**
  115. * Muestra el resultado final de la partida.
  116. *
  117. * @param arbitro
  118. *            arbitro
  119. */
  120. private static void mostrarResultadoFinalPartida(ArbitroAtariGo arbitro) {
  121. mostrarTablero(arbitro.obtenerTablero());
  122. System.out.println();
  123. Jugador jugador = arbitro.obtenerGanador();
  124. System.out.println("El ganador es " + jugador.obtenerNombre());
  125. }
  126.  
  127. /**
  128. * Valida los argumentos del juego introducidos por teclado.
  129. *
  130. * @param args
  131. *            argumentos
  132. * @return true si son correctos, false en caso contario
  133. */
  134. private static boolean sonArgumentosValidos(String[] args) {
  135. boolean validacion = true;
  136. if (args.length != 0 && args.length != 3) {
  137. validacion = false;
  138. } else if (args.length == 3) {
  139. // Validacion de tamaños de teclado.
  140. tamaño = Integer.parseInt(args[2]);
  141. if (!ConfiguracionAtariGo.esTamañoValido(tamaño)) {
  142. validacion = false;
  143. }
  144. }
  145. return validacion;
  146. }
  147.  
  148. /**
  149. * Inicializa los elementos del juego. Se supone que los argumentos han sido
  150. * validados previamente.
  151. *
  152. * @param args
  153. *            argumentos válidos
  154. */
  155. private static void inicializarConArgumentos(String[] args) {
  156. assert sonArgumentosValidos(args);
  157. String jugador1;
  158. String jugador2;
  159. if (args.length == 0) {
  160. // Valores por defecto
  161. tamaño = ConfiguracionAtariGo.TAMAÑO_POR_DEFECTO;
  162. jugador1 = "Abel";
  163. jugador2 = "Caín";
  164. } else {
  165. tamaño = Integer.parseInt(args[2]);
  166. jugador1 = args[0];
  167. jugador2 = args[1];
  168. }
  169. inicializarArbitro(jugador1, jugador2, tamaño);
  170. }
  171.  
  172. /**
  173. * Inicializa el árbitro.
  174. *
  175. * @param jugador1 jugador1
  176. * @param jugador2 jugador2
  177. * @param tamaño tamaño
  178. */
  179. private static void inicializarArbitro(String jugador1, String jugador2, int tamaño) {
  180. Tablero tablero = new Tablero(tamaño, tamaño);
  181. arbitro = new ArbitroAtariGo(tablero);
  182. arbitro.registrarJugadoresEnOrden(jugador1);
  183. arbitro.registrarJugadoresEnOrden(jugador2);
  184. }
  185.  
  186. /**
  187. * Muestra la ayuda en línea para la inicialización correcta del juego.
  188. */
  189. private static void mostrarAyuda() {
  190. System.out.println("Juego del AtariGo");
  191. System.out.println();
  192. System.out.println("Uso1: java juego.textui.AtariGo nombreJugador1 nombreJugador2 tamaño");
  193. System.out.println("Uso2 (valores por defecto): java juego.textui.AtariGo");
  194. System.err.println("Tamaño debe ser uno de los permitidos en la configuración del juego."
  195. + ConfiguracionAtariGo.generarAyuda());
  196. }
  197.  
  198. /**
  199. * Muestra el estado actual del tablero.
  200. *
  201. * @param tablero
  202. *            tablero a pintar en pantalla.
  203. */
  204. private static void mostrarTablero(Tablero tablero) {
  205. pintarFilas(tablero);
  206. pintarLetrasEnLineaInferior(tablero);
  207. }
  208.  
  209.  
  210. /**
  211. * Pinta las filas con el número correspondiente y las piedras en cada fila.
  212. *
  213. * @param tablero
  214. *            tablero
  215. */
  216. private static void pintarFilas(Tablero tablero) {
  217. System.out.println();
  218. for (int i = 0; i < tablero.obtenerNumeroFilas(); i++) {
  219. System.out.print((tablero.obtenerNumeroFilas() - i) + "\t");
  220. for (int j = 0; j < tablero.obtenerNumeroColumnas(); j++) {
  221. Celda celda = tablero.obtenerCelda(i, j);
  222. if (celda.estaVacia()) {
  223. System.out.print(" - ");
  224. } else {
  225. Color color = celda.obtenerColorDePiedra();
  226. System.out.printf(" %s ", color.toChar());
  227. }
  228. }
  229. System.out.println();
  230. }
  231. }
  232.  
  233. /**
  234. * Pinta la fila inferior con las letras.
  235. *
  236. * @param tablero
  237. *            tablero
  238. */
  239. private static void pintarLetrasEnLineaInferior(Tablero tablero) {
  240. System.out.println();
  241. System.out.print("\t");
  242. for (int i = 0; i < tablero.obtenerNumeroColumnas() + 1; i++) {
  243. char letra = (char) (i + 'A');
  244. if (letra != ConfiguracionAtariGo.LETRA_NO_UTILIZADA) {
  245. System.out.print(" " + letra + " ");
  246. }
  247. }
  248. System.out.println();
  249. }
  250. }

Código
  1. package juego.modelo;
  2.  
  3. /**
  4.  * Clase celda
  5.  * Metodologia de la Programacion.
  6.  * 2&#65533; ITIG - Curso 2017-2018.
  7.  * Interfaz en modo texto del juego.
  8.  *
  9.  * @author Pablo Seoane Fuente y Sergio Ruiz Orodea
  10.  * @version 1.0
  11.  *
  12.  */
  13. public class Celda {
  14.  
  15. private int fila;
  16. private int columna;
  17. private Piedra piedra;
  18.  
  19. /**
  20. * Constructor de Celda
  21. *
  22. * @param fila
  23. *            Fila de celda
  24. * @param columna
  25. *            Columna de la celda
  26. */
  27. public Celda(int fila, int columna) {
  28. this.columna = columna;
  29. this.fila = fila;
  30. }
  31.  
  32. /**
  33. * Devuelve la piedra asignada a la celda
  34. * @return
  35. */
  36. public Piedra obtenerPiedra() {
  37. return this.piedra;
  38. }
  39.  
  40. /**
  41. * Devuelve el color de la piedra
  42. * @return
  43. */
  44. public Color obtenerColorDePiedra() {
  45. return this.piedra.obtenerColor();
  46. }
  47.  
  48. /**
  49. * Establecer la piedra
  50. *
  51. * @param piedra
  52. * Piedra a establecer
  53. */
  54. public void establecerPiedra(Piedra piedra) {
  55. this.piedra = piedra;
  56. }
  57.  
  58. /**
  59.  * Devuelve si la celda esta vacia
  60.  * @return Boolean indicado si esta vacia
  61.  */
  62. public boolean estaVacia() {
  63. return obtenerPiedra() == null;
  64.  
  65. }
  66.  
  67. /**
  68. * Devuleve la fila de la celda
  69. * @return
  70. */
  71. public int obtenerFila() {
  72. return this.fila;
  73. }
  74.  
  75. /**
  76. * Devuelve la columna de la celda
  77. * @return
  78. */
  79. public int obtenerColumna() {
  80. return this.columna;
  81. }
  82.  
  83. /**
  84. * Comprueba iguales coordenadas
  85. * @return
  86. */
  87. public boolean tieneIgualesCoordenadas(Celda celda2){
  88. return this.obtenerFila() == celda2.obtenerFila() && this.obtenerColumna() == celda2.obtenerColumna();
  89. }
  90. /**
  91. * Comprueba iguales coordenadas
  92. * @return
  93. */
  94. public void eliminarPiedra(){
  95. this.piedra = null;
  96. }
  97.  
  98. /**
  99. * Sobrescribir el metodo toString
  100. */
  101. public String toString() {
  102. return "Celda[Fila: " +obtenerFila()+ ", Columna: " +obtenerColumna()+ " y Piedra: " +obtenerPiedra()+ "]";
  103. }
  104.  
  105. }
  106.  


En línea

user-marcos

Desconectado Desconectado

Mensajes: 159


Ver Perfil
Re: AYUDA urgente entrega de trabajo en 1 hora
« Respuesta #1 en: 17 Noviembre 2017, 23:21 pm »

Has hecho new a arbitro?


En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines