Introducción

Esta práctica amplia la anterior añadiendo dos interfaces:

• una llamada IPlayer para simular un jugador disparando al tablero de un segundo jugador;
• otra llamada IVisualiser para visualizar los dos tableros usados en el juego del Hundir la flota, un tablero para cada jugador.

La interfaz IPlayer será implementada en esta práctica por dos clases, cada una representa un tipo diferente de jugador. La interfaz IVisualiser será implementada por dos clases que producirán una representación diferente de los tableros. Ten en cuenta, sin embargo, que dado que la mayor parte de tu código utilizará los tipos de interfaz y no una subclase en particular, se podrían añadir a la aplicación nuevos jugadores o visualizadores sin problemas, con pequeños cambios en el código existente.

Como complemento a estas interfaces, y con el objetivo de instanciar fácilmente los objetos de las clases que las implementan, se crearán nuevos métodos factoría. Además, pueden surgir nuevas situaciones de error y, en consecuencia, se añadirán nuevas excepciones al modelo.   Finalmente, implementaremos una clase Game para manejar el juego.

Tendrás que consultar la documentación de la API de Java 8 para saber cómo trabajar con algunas de las clases que usaremos en esta práctica.

Diagrama de clase

Estos son los diagramas de clase UML que representan las clases en nuestro modelo:

En las siguientes secciones se indican los métodos que hay que modificar o implementar desde cero para esta práctica. Los atributos o relaciones no se explicarán, ya que ya se muestran en el diagrama UML. Los elementos que no cambian con respecto a la práctica anterior no se explicarán de nuevo. Tampoco se comentarán los setters o getters que simplemente devuelven el valor actual de una propiedad, o establecen una propiedad a un nuevo valor. Tendrás que decidir cuándo usar copia defensiva en un setter o getter mirando el diagrama de clases.

Cuando se indique, tu código debe comprobar que los valores de los argumentos pasados a un método son correctos. Los argumentos que son referencias no necesitan ser comprobados, a menos que se indique lo contrario.

Estructura de paquetes y directorios

Crearemos tres nuevos paquetes:

• model.io para las interfaces y las clases que las implementan;
• model.exceptions.io para una nueva clase para los errores relacionados con la entrada/salida;
• model.io.gif para dos clases, que no tendrás que implementar, y que usarás para generar GIF animados.

Hoja de ruta

Se recomienda encarecidamente que implementes tu solución en el mismo orden que se sigue en este documento.

1. Implementa las clases para las nuevas excepciones.
2. Implementa el método de factoría en CraftFactory.
3. Implementa la interfaz IPlayer, las clases que la implementan y los métodos de factoría correspondientes.
4. Implementa la interfaz IVisualiser, las clases que lo implementan y los correspondientes métodos de factoría.
5. Implementa la clase Game.

Método createCraft(String, Orientation)

El primer parámetro es el tipo de nave (nombre de la clase que se utilizará para crearla); el segundo es la orientación que se utilizará para crear la nave.

Este método crea la nave correspondiente y la devuelve; si no se conoce el tipo de nave que se va a crear, se devuelve null.

Clase PlayerFile

Esta clase implementa la interfaz IPlayer. Permite jugar al juego leyendo comandos de un archivo de texto que contendrá una línea para cada comando diferente. Cada comando recibe un número diferente de parámetros separados por uno o más caracteres de espacio en blanco. La siguiente lista ilustra los comandos válidos en un tablero 2D (su significado es obvio y no se explica; obsérvese de nuevo que puede aparecer cualquier número de caracteres de espacio en blanco entre un comando y sus parámetros):

put  Cruiser NORTH -1 2
put Destroyer  EAST 3 3
put Carrier WEST 6   4
put Battleship SOUTH 1 0
endput
shoot 0 3
shoot 1 3
shoot 0  1
exit

Algunos comandos no válidos son “PUT Cruiser NORTH 0 1” (los comandos válidos distinguen entre mayúsculas y minúsculas), “put Cruiser NORTH 0” (falta un parámetro), “shooooot 0 3”, o “shoot a b c”.

En un tablero 3D los comandos válidos se verían de la siguiente manera:

put Cruiser NORTH -1 2 0
endput
shoot 0 1 1
exit

Importante:

• Después de “endput” no se pueden colocar nuevos comandos “put”.
• Antes de “endput” no se permiten comandos “shoot”.
• Cualquier comando después de “exit” es ignorado.
• Todos los comandos terminan con ‘\n’.

Martin (PlayerFile)

Clase PlayerRandom

Esta clase implementa la interfaz IPlayer. Se comporta como un jugador ciego aleatorio, decidiendo aleatoriamente las coordenadas donde se ponen las naves y aviones y las coordenadas a disparar.

Los números aleatorios no son estrictamente posibles con un ordenador si no tiene sensores conectados al mundo exterior. Para asegurar cierta aleatoriedad, se utiliza un semilla para establecer el punto de partida de la fórmula que genera una secuencia de números pseudo-aleatorios (a esta semilla se le suele dar un valor basado en la fecha y hora actuales). Si no se cambia el generador de la secuencia, siempre se recuperará la misma secuencia si se utiliza la misma semilla. Como esta práctica se evaluará automáticamente, la semilla se pasará al constructor para que cada ejecución pueda ser fácilmente reproducida una y otra vez, siempre que la semilla no se cambie.

El JDK proporciona la clase java.util.Random para la generación de números aleatorios. El siguiente código de ejemplo establece la semilla en 12345 y genera un número entero aleatorio entre 0 y 99 (ambos números incluidos):

Random random = new Random(12345);
int r = random.nextInt(100);

Martin (PlayerRandom)

private int genRandomInt(int min, int max) { 
    return random.nextInt(max-min)+min;
}

genRandomInt(0-offset, b.getSize());

Clase PlayerFactory

Esta clase simplemente proporciona un método factoría para crear objetos de las diferentes clases que implementan IPlayer.

Clase VisualiserConsole

Esta clase implementa la interfaz IVisualiser. Nos permite producir una representación de la partida en forma de cadena a través de la salida estándar.

Clase VisualiserGIF

Esta clase implementa la interfaz IVisualiser. Nos permite producir un GIF animado que representa la partida. Para poder generar estas imágenes tienes que:

1. Descargar la librería de terceros GIF4J, es un archivo JAR. Cópiarlo en una carpeta con el nombre lib dentro de tu proyecto Eclipse y refresca la vista del proyecto. Luego, ve a Project -> Properties, opción Java Build Path, pestaña Libraries y presiona Add JARs…, luego selecciona el archivo gif4j_light_trial_1.0.jar.
2. Crear un paquete con el nombre model.io.gif, descargar los archivos AnimatedGIF.java y FrameGIF.java y añadirlos al paquete recién creado.

FrameGIF frame = new FrameGIF(w, h*2+1);

frame.printSquare(column, row, Color.LIGHT_GRAY);

agif.addFrame(frame);

agif.saveFile(new File("files/output.gif"));

Clase VisualiserFactory

Esta clase simplemente proporciona un método factoría para crear objetos de las diferentes clases que implementan IVisualiser.

Método Game(Tablero, Tablero, IPlayer, IPlayer)

Este constructor almacena los dos tableros y jugadores recibidos como argumentos en los atributos correspondientes de la clase. También establece el flag gameStarted a false.

Exceptions: Lanza la excepción NullPointerException si alguno de sus parámetros es nulo.

Método start()

Este método comienza la partida haciendo que los jugadores pongan sus barcos/aviones en sus tableros. El jugador player1 pone sus barcos/aviones en el tablero board1; el jugador player2 pone sus barcos/aviones en el tablero board2. También inicializa los atributos gameStarted, shootCounter y nextToShoot.

Excepciones: Cualquier excepción lanzada por las llamadas a IPlayer.putCrafts(·) debe ser relanzada como RuntimeException.

Método gameEnded()

Devuelve true si la partida ha terminado. Una partida se considera terminada si se inició y todas las naves de uno de los tableros han sido destruidas.

Método playNext()

Este método hace que el jugador que debe jugar dispare al tablero del oponente. El jugador player1 dispara al tablero board2, y el jugador player2 dispara al tablero board1. Este método devuelve true si el jugador realmente disparó al tablero del oponente (independientemente del resultado, incluso si disparó a una coordenada ya alcanzada), false en caso contrario.

Si el método va a devolver true, actualiza el contador de disparos y el atributo nextToShoot antes de acabar.

Excepciones: si las excepciones BattleshipIOException o InvalidCoordinateException son lanzadas por cualquiera de los métodos utilizados por este método, la excepción es lanzada de nuevo como RuntimeException (y no se realiza ninguna actualización del contador de disparos ni del atributo nextToShoot). Si se lanza la excepción CoordinateAlreadyHitException, se imprime un mensaje a través de la salida estándar; este mensaje debe incluir la cadena Action by, el nombre del jugador que disparó y el mensaje de error de la excepción:

Action by Mary (PlayerRandom)...

Método getPlayerLastShoot()

Este método devuelve el jugador que disparó en último lugar o null si ninguno de los jugadores ha disparado todavía.

Método playGame(IVisualiser)

Este método inicia la partida y juega hasta que la partida termina o el jugador que debe disparar a continuación no tiene más tiros que realizar (Game.playNext() devuelve false).

El método utiliza el visualizador recibido como argumento para mostrar la partida a medida que progresa; para ello llama al método IVisualiser.show(). Nótese que IVisualiser.show() debe ser llamado después de comenzar la partida (y antes de que el primer jugador empiece a disparar) y después de cada llamada a Game.playNext() si devuelve true.

Una vez que la partida ha terminado, o el jugador que debe disparar a continuación no tiene más tiros que realizar, el método debe cerrar el visualizador (IVisualiser.close()).

Método toString()

Este método devuelve una cadena que representa el estado de la partida. Lo que sigue en un ejemplo de la cadena que representa una partida con tableros 2D de tamaño 10:

=== ONGOING GAME ===
==================================
John (PlayerRandom)
==================================
 ??   ?  ?
 ? ???    
 ?   •  ? 
   ? • ?••
    ?•? ? 
   ? ? •  
 ? ?   ? ?
      ?• ?
?      •  
 ?  ΩΩ •? 
==================================
Mary (PlayerRandom)
==================================
  •   ? ? 
  ?      ?
? •   ?   
? ?    ?  
  ?       
 •??     ?
   ?      
   ? ?    
 •?•••? Ω 
    ??  Ω 
==================================
Number of shots: 281

Esta cadena comienza con === GAME NOT STARTED ===, === GAME ENDED === o === ONGOING GAME ===, dependiendo de si la partida no se ha iniciado, ya ha terminado o está en juego. A continuación tiene los tableros de los dos jugadores (junto con el nombre de los jugadores). Después de eso, la cadena incluye el número de tiros realizados hasta ahora.

Si la partida terminó y todas las naves en uno de los tableros fueron destruidas, se debe añadir al final una línea con el nombre del ganador. Esta línea debe ser de la siguiente manera:

Mary (PlayerRandom) wins

Importante: La cadena que representa el juego no debe terminar con ‘\n’.

Pruebas previas

Aquí tienes los pre-tests. Copia las carpetas creadas al descomprimirlo en la carpeta test de tu proyecto.

Hay algunas pruebas que deben ser completadas en cada archivo (busca el comentario //TODO). También se usarán para calificar tu práctica, así que merece la pena intentar completarlas para que puedas obtener una buena nota. Lo más probable es que se te pida que escribas algunas pruebas unitarias en el examen práctico, así que asegúrate de que sabes cómo hacerlo.