Introduction

This assignment will extend the previous one by adding two interfaces:

• one called IPlayer for simulating a player shooting at the board of a second player;
• another called IVisualiser for visualising the two boards used in the Battleship game, one board for each player.

The IPlayer interface will be implemented in this assignment by two classes, each one representing a different type of player. The IVisualiser interface will be implemented by two classes producing a different representation of the boards. Note, however, that since most of your code will use the interface types and not a particular sub-class, new players or visualisers could smoothly be added to your application with minor changes to the existing code.

As a complement to these interfaces, and with the aim of easily instantiating objects of the classes implementing them, new factory methods will be created. Also, new error situations may arise and, consequently, new exceptions will be added to the model.   Finally, we will implement a class Game for handling the game.

You will have to look up the Java 8 API Documentation to know how to work with some of the classes we will use in this practical assignment.

Class diagram

These are the UML class diagrams that represent the classes in our model:

The following sections describe all the methods that you have to modify or implement from scratch for this assignment. Attributes or relationships will not be covered as they are already shown in the UML diagram. Elements which do not change with regard to the previous assignment will not be explained again. Setters or getters which simply return the current value of a property, or set a property to a new value, will not be commented either. You will have to decide when to use defensive copy in a setter or getter by looking at the class diagram.

When indicated, your code must check that the argument values passed to a method are correct. The arguments that are references do not need to be checked, unless otherwise stated.

Package structure and directories

We will create three new packages:

• model.io for the interfaces and the classes implementing them;
• model.exceptions.io for a new class for input/output related errors;
• model.io.gif for two classes, that you will not have to implement, to be used to generate animated GIF images.

Roadmap

It is strongly recommended that you implement your solution in the very same order followed in this document.

1. Implement the classes dealing with new exceptions.
2. Implement the factory method in CraftFactory.
3. Implement the interface IPlayer, the classes implementing it and the corresponding factory methods.
4. Implement the interface IVisualiser, the classes implementing it and the corresponding factory methods.
5. Implement the class Game.

Method createCraft(String, Orientation)

The first parameter is the type of craft (name of the class to be used to create it); the second one is the orientation to be used for creating the craft.

This methods creates the corresponding craft and returns it; if the type of craft to be created is not known, it returns null.

Class PlayerFile

This class implements the interface IPlayer. It allows to play the game by reading commands from a text file that will contain one line for each different command. Each command receives a different number of parameters separated by one or more whitespace characters. The following list illustrates the valid commands in a 2D board (their meaning is obvious and are not explained; note again that any number of whitespace characters may appear between a command and its parameters):

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

Invalid input strings are “PUT Cruiser NORTH 0 1” (valid commands are case-sensitive), “put Cruiser NORTH 0” (a parameter is missing), “shooooot 0 3”, or “shoot a b c”.

On a 3D board the valid commands would look as follows:

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

To take into account:

• After “endput” no new “put” commands can be placed.
• Before “endput” no “shoot” commands are allowed.
• Any command after “exit” is ignored.
• All commands are terminated with ‘\n’.

Martin (PlayerFile)

Class PlayerRandom

This class implements the interface IPlayer. It behaves as a random blind player, randomly deciding the coordinates where ships and aircrafts are put and the coordinates to shoot.

Random numbers are strictly not possible with a computer if it does not have sensors connected to the outside world. In order to ensure some randomness, a seed is used in order to set the starting point for the formula which generates a sequence of pseudo-random numbers (this seed is usually given a value based on the current date and time). If the sequence generator is not changed, the same sequence will always be retrieved if the same seed is used. As your solution to this assignment will be automatically evaluated, the seed will be passed to the constructor so that each execution can be easily reproduced over and over provided that the seed is not changed.

The JDK provides the java.util.Random class for random number generation. The following code sets the seed to 12345 and generates a random integer between 0 and 99 (both numbers included):

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());

Class PlayerFactory

This class simply provides a factory method to create objects of the different classes that implement IPlayer.

Class VisualiserConsole

This class implements the interface IVisualiser. It allows us to produce a string representation of the game through the standard output.

Class VisualiserGIF

This class implements the interface IVisualiser. It allows us to produce an animated GIF image representation of the game. In order to be able to generate these images you have to:

1. Download the third-party library GIF4J, it is a JAR file. Copy it to a folder with name lib inside your Eclipse project and refresh the view of the project. Then, go to Project -> Properties, option Java Build Path, tab Libraries and press Add JARs…, then select the file gif4j_light_trial_1.0.jar.
2. Create a package with name model.io.gif, download the files AnimatedGIF.java and FrameGIF.java and add them to the newly created package.

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"));

Class VisualiserFactory

This class simply provides a factory method to create objects of the different classes that implement IVisualiser.

Method Game(Board, Board, IPlayer, IPlayer)

This constructor stores the two boards and players received as arguments in the corresponding attributes of the class. It also sets the flag gameStarted to false.

Exceptions: It throws the exception NullPointerException if any of its parameters is null.

Method start()

This method starts the game by making the players to put their ships/aircrafts on their boards. Player 1 puts her ships/aircrafts on board 1; player 2 puts her ships/aircrafts on board 2. It also initialises the attributes gameStarted, shootCounter and nextToShoot.

Exceptions: Any exception thrown by the calls to IPlayer.putCrafts(·) must be re-thrown as a RuntimeException.

Method gameEnded()

It returns true if the game has finished. A game is considered to be finished if it was started and all the crafts on one of the boards have been destroyed.

Method playNext()

This method makes the player that should play next to shoot at the opponent’s board. Player 1 shoots at board 2, and player 2 shoots at board 1. This method returns true if the player actually shot the opponent’s board (regardless of the result, even if she shot at a coordinate already hit), false otherwise.

If the method is to return true, it updates the shoot counter and the nextToShoot attribute before returning.

Exceptions: if the exceptions BattleshipIOException or InvalidCoordinateException are thrown by any of the methods used by this method, the exception is re-thrown as RuntimeException (and no update of the shoot counter and the nextToShoot attribute is performed). If the exception CoordinateAlreadyHitException is thrown, a message is print through the standard output; this message must include the text Action by, the name of the player that shot and the error message of the exception:

Action by Mary (PlayerRandom)...

Method getPlayerLastShoot()

This method returns the player that shot last or null if none of the player has shot yet.

Method playGame(IVisualiser)

This method starts the game and plays the game till the game is ended or the player that should shoot next has no more shots to perform (Game.playNext() returns false).

The method makes use of the visualiser received as argument to show the game as it progresses; to do so it calls the method IVisualiser.show(). Note that IVisualiser.show() must be called after starting the game (and before the first player starts shooting) and after each call to Game.playNext() if it returned true.

Once the game is ended, or the player that should shoot next has not more shots to perform, the method must close the visualiser (IVisualiser.close()).

Method toString()

This method returns a string representing the state of the game. What follows in a example of the string representing a game with 2D boards of size 10:

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

This string starts with === GAME NOT STARTED ===, === GAME ENDED === or === ONGOING GAME ===, depending on whether the games was not started, it already ended or is being played. It then contains the boards of the two players (together with the name of the players). After that the string includes the number of shots performed so far.

If the game was ended and all crafts in one of the boards were destroyed, a line with the name of the winner is finally added to the string representing the game. This line should look as follows:

Mary (PlayerRandom) wins

To take into account: The string representing the game is not terminated with ‘\n’.

Previous tests

Here you can download the pre-tests. Copy the folders that are created when you unzip it into the folder test of your project.

There are some tests to be completed in each file (look for the comment //TODO). These will also be used to grade your assignment, so it is worth trying to complete them, so you can get a good score. Most probably, you will be required to write some unit tests in the practical exam, so make yourself sure you know how to code them!