Introduction

The design proposed for the previous assignment had an issue which will be solved in the current one: the craft and visualiser factories were not completely open for extension, as adding a new type of craft or visualiser would imply adding a new conditional statement or a new case clause to a switch statement. In this assignment, this will be fixed by conveniently introducing reflection. Moreover, the model will be extended with a ranking system that will be able to track the scores obtained after playing each game and sort them according to two different criteria: the amount of positions hit and the value of the different crafts shot down.  

Class diagram

This is the UML class diagram that represents the new 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 two new packages:

• model.score for the classes implementing the scoring and ranking system;
• model.exceptions.score for a new class for errors related to the scoring/ranking.

Roadmap

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

1. Introduce reflection
2. Implement the scoring system
3. Introduce the changes explained below to existing classes

Class Score

The new abstract class Score encapsulates the concept of the score of a game. As the goal is to create a ranking system, scores need to be comparable. This will be accomplished by making Score implement the Java interface Comparable, in particular Comparable<Score<T>>, thus forcing the class to implement the method compareTo(·):

public abstract class Score<T> implements Comparable<Score<T>>{   
   ...   
}

The type T will determine the type of score to be defined.

Non-abstract sub-classes of Score will implement the method score(·) that, when appropriate, increments the attribute score; higher values of this score will mean better performance of the player. The attribute score will be used in the method Score.compareTo(·) to compare two different scores.

Julia (PlayerFile): 7

Class HitScore

This class represents a scorer based on CellStatus and simply keeps the count of positions hit by the player. It must be declared as follows:

public class HitScore extends Score<CellStatus> {
   ...
}

Class CraftScore

This class represents a scorer based on Craft and adds up the value of the different crafts shot down by the player. It is declared in a way analogous to that of HitScore but using Craft instead of CellStatus.

Class Ranking

In order to have a ranking system based on the scores obtained by the different players, a new class Ranking will be added. Ranking is a generic class that has a bounded type parameter in order to prevent scores of different types from co-existing in a particular ranking:

class Ranking<ScoreType extends Score<?>> {
   ...
}

Therefore, an object of type Ranking will have to be created in one of two ways, either as

Ranking<HitScore> rh = new Ranking<>();

or as

Ranking<CraftScore> rc = new Ranking<>();

Consequently, a compiler error will prevent the client code from adding scores of different criteria to the same ranking object (try it when you have these classes already implemented). Notice that from Java 7 the type arguments required to invoke the constructor of a generic class can be replaced with an empty set (the pair of angle brackets is called the diamond) provided that the compiler can infer the types from the context.

private SortedSet<ScoreType> scoreSet;

scoreSet = new TreeSet<>();

Class Craft and its sub-classes

The different ships and aircraft will have a value that will be used by the scoring systems. For this you have to:

• Add to Craft an abstract method getValue(), returning and int and with no parameters.
• Implement the method getValue() in the sub-classes of Ship and Aircraft. The value they should return is shown in the following table:

Interface IPlayer

Add the new method getLastShotStatus().

Class PlayerRandom

These are the changes to be introduced:

• The method PlayerRandom.putCrafts() needs to be modified to include the name of the sub-package (ship or aircraft) in the different calls to CraftFactory.createCraft(·).
• In PlayerRandom.nextShoot(), the status returned by Board.hit(·) must be stored in the attribute lastShotStatus.
• Implement the getter PlayerRandom.getLastShotStatus().

Class PlayerFile

Changes to be introduced:

• In PlayerFile.nextShoot(), the status returned by Board.hit(·) must be stored in the attribute lastShotStatus. If no shot is performed, for example because the exit command is read from the input file or because there are no more lines to read, lastShotStatus must be set to null.
• Implement the getter PlayerFile.getLastShotStatus().

In addition, the input files used with PlayerFile need to be updated. You can download an updated version of the files playerfile-john.txt and playerfile-mary.txt that include the non-common prefix when specifying the ship/aircraft in a put command.

Class Game

These are the changes to be introduced:

• In the constructor of the class the attributes hitScore1, hitScore2, craftScore1 and craftScore2 must be initialised.
• In Game.playNext(), after the player shoots, the corresponding hitScore is updated by calling HitScore.score(·) with the status of the last shot performed by the player (use method IPlayer.getLastShotStatus() to obtain this status). In addition, if this status is DESTROYED, update the corresponding craftScore by calling CraftScore.score(·) with the craft that was shot down.
• Implement method Game.getScoreInfo(). It should return a string with information about the scores of the two players. Here is an example of the output:

Player 1
HitScore: John (PlayerFile): 9
CraftScore: John (PlayerFile): 11
--------------
Player 2
HitScore: Mary (PlayerFile): 10
CraftScore: Mary (PlayerFile): 6

Previous tests

In this last assignment you should write your own JUnit tests for each of the implemented methods.