COMPSCI4039代写、Python，c++编程代做

日期：2023-11-08 07:44

COMPSCI4039 – Programming IT

AE2: Battleship

There is a FAQ at the end of this document, please read it.

Introduction

Battleship is a popular board game involving 2 players. The aim of the game is for the players

to place their ships on a grid and then guess the positions of their opponents’ ships. Full rules

can be found here. https://www.thesprucecrafts.com/the-basic-rules-of-battleship-411069

In this assessment you are being asked to program a simpler version of this game. Initially,

the battleships will be placed on a 10x10 grid randomly, players will then proceed to guess

where the ships are on the board. If they guess correctly, they ‘hit’ the battleship, otherwise

they ‘miss’. The objective of the game for both players is to find and sink all the battleships

on the board. The player who hits more ships than the other, wins after all ships have been

destroyed.

In this assessment you will create classes and logic necessary to run a game of battleship.

This assessment is split into multiple sections. Partial marks will be awarded in this

assessment, so you do not need to complete the project in full to be awarded marks. A

maximum number of marks that can be awarded for each section is shown to help you manage

your time with this assessment.

The marking scheme is below. Marks will be awarded for:

- Functional correctness

- Sound OO design

- Clean, tidy and commented code

The marks are awarded out of 22. Remember that you do not need to complete the project to

be awarded marks. You do not need to complete a section or task to completion to be awarded

marks. Partial marks will be awarded in the event you can demonstrate an attempt that was

made to address the task.

Part 1: The Players and the Square classes

This following image provides an idea on what the board should look like:

There are 10 rows and 10 columns. Each cell in the board is a Square object. Each square

object must consist of:

- An integer denoting the row position, inclusive of 0.

- An integer denoting the column position, inclusive of 0.

- An attribute to indicate whether the square has a ship in it.

- A reference to a battleship if one is currently on the Square.

- An attribute to indicate whether the player has fired a shot at the square.

You will also require appropriate getters and setters to utilise this class within the assessment.

Each player class should have a reference to a board object they will play the game with. Their

name, and scores. Make these attributes private. The constructor to the Player class should

take in the name of the player, along with a reference to the board that will be associated with

the player object.

Each player will have a method to take turns. This method will be called from the main

controlling logic of the game.

[5 marks]

Part 2 – The board and Battleship classes

You are to specify a Battleship class. This class should specify the following attributes:

- Whether it is sunk.

- The remaining health (how many more hits it can take before sinking)

- The size of the ship.

Each Battleship object will be checked against whenever a player fires into the board on a

particular square. In the event the player hits the ship, it will be necessary for you to decrease

the health of the ship and of course update its state in the event the ship is destroyed. A

battleship should be specified as being 2 units in size, therefore it is to take up 2 squares when

it is placed on the board. The size of the ship will directly correspond to the amount of health

the ship has.

The board constructor should take in two values representing the number of rows and

columns, again you can assume that these values will be 10 when testing your program. The

board class itself should have two methods, one to populate the board data structure with

Square objects. The other will be responsible for generating battleships.

When generating battleships, the placement of the ships should follow certain restrictions. Of

course, you should ensure in your code that the ship length does not mean it will exist out of

bounds of the board. In addition, you are to ensure that ships do not overlap when they are

placed on the board. Placement of the ships must be randomised. You can use the following

code to generate a random generator.

Random r = new Random();

r.nextInt(n);

In addition to this, you are to also have some ships placed vertically on the board, whilst others

are horizontal. Again, this should be randomised, you can use the following ‘coin flip’ code to

achieve this:

Random r = new Random();

Return r.nextBoolean();

You are to place 5 battleships on the board at random, in random orientations.

[5 marks]

Part 3 – Playing the Game

When creating Player objects, the users should be prompted for their names and have this

be used as input to the constructors. Players have a takeTurn method, which should be

called from a main game loop within the main class. This method should prompt the user to

input their guess from the console. You can assume that the user will input their guess as ‘x y’

where x represents the row and y represents the column that is to be targeted. The traditional

game uses letter + number combinations, you are not expected to use this when requesting

player input. Column and row numbers will be fine.

Within the main class, add logic to allow players to take turns by implementing the takeTurn

method. You do not need to check for improper input and can assume that users will enter

correct information that is within bounds. The takeTurn method should return a boolean, if

true then the player has hit and sunk the final battleship and has ended the game. Otherwise,

the game continues, and the method returns false.

The player can only damage the ship in the event they land a fresh hit on it (i.e. they cannot

hit the ship in the same square twice and have it count. Your code must check for this and

prevent players from damaging the ship multiple times in the same square. Likewise, your

code should also check for areas that have already been fired at. In the event the player enters

coordinates that have been checked prior, they will lose their turn.

After each turn, the game should announce an update to the player (prompting the player for

their guess, and indicating whether the guess either hit, missed, is invalid or has ended the

game. If a player sinks a ship, they score a point. The game ends when a player sinks the last

ship, so you will want to track how many ships have been sunk, and how many are left in the

game. The winner is the player with the most points. If the points are equal, then it is a draw.

[4 marks]

Part 4 – Visualising the Game

The board class should have a method, toString that will allow the current state of the board

to be displayed to the console. The minimum information necessary is presented in the figure

in this document. It is not necessary to have extra information to score full marks.

The toString method should invoke the toString representation of each Square object

within the data structure. The Squares class should have a toString method that will

return a representation of the square. If the player has not interacted with a square then the

representation should be ‘-‘, if the player has fired and missed, then the square representation

should be ‘o’ and finally ‘x’ if they have hit a ship. Each square should be printed with

String.format to exactly 3 spaces in length.

On each turn, the grid is to be updated to reflect the changes the players make to the board.

So if they fire at a square and miss, then this should immediately be announced and the board

updated before the next player takes their turn. Likewise, if they hit a ship then the board

should be updated to reflect this and a hit should be announced. A Square object can have a

battleship associated with it and this information should be used to inform the toString

method in the Square class.

[4 marks]

Part 5 – Expanding on the Battleships

Expand on what you have implemented with the Battleship class to specify multiple

subclasses. A SmallBattleship, MediumBattleship and LargeBattleship should all

inherit from the Battleship superclass.

Each sub-class should specify to the super class constructor specific information that will be

hard coded and therefore specific to that sub class. In addition, you are to specify a static

attribute for each sub class. This attribute should specify the total number of permissible ships

of that class on the board. The following information should be associated with each class.

- SmallBattleship should have a size of 1, and there must be 3 on the board.

- MediumBattleship should have a size of 2, and there must be 2 on the board.

- LargeBattleship should have a size of 3, and there must be 1 on the board.

Update your placement logic to take into consideration the different battleship types that may

exist on the board. Therefore, you should no longer have 5 ships that are of length 2, but you

should now have 3 ships that are a single square in size, 2 that are 2 squares in size, and 1 ship

that is 3 squares in size. You should use the static attributes for this. Again, ensure that these

are randomly placed, and that there are no overlaps or placements that are out of bounds.

Each battleship object is still worth 1 point when sunk.

[4 marks]

FAQ

1. Is it important to make flashy graphics for my board? No. Functionality is what we’re

after here.

2. Part 5 asks to expand on Battleships: does this mean I have to submit two versions of

the code? No, there is no need to submit two versions of the code, so your final

submission does not need to play the game with only size 2 Battleships. However, going

through that stage of development is likely to be the most sensible way to develop the

code so we’d advise against attempt to start with a version of the game with the

Battleships detailed in Part 5.

3. Should I comment my code? Yes. Your code is the only thing you will submit. We reserve

the right to penalise because we cannot understand, even if the code works. Provide

clear comments.

4. Should I provide unit tests? You can get 100% of the marks without them. However,

writing tests will help you to get things working quicker. If you do write them, feel free

to submit them. However, you are not expected to write unit tests.

5. If I can’t get something to work, what should I do? We can sometimes award marks for

you telling us (in comments) how you might get something to work so if something

isn’t working, tell us why you think that is.

6. How long should I spend on this assessed exercise? Hard to say. However, we find every

year that students spend way too long on AEs.

7. I want to extend my code more as programming practice, any suggestions? Great! It’s

a good way to improve your programming. One thing you could do is to consider

creating additional ship classes to better reflect the original game of Battleship. You

could also update the scoring logic to say, have different ships award different points.

You could also if you really wanted to, work on a GUI that could be used here. However

please note that if you want to work on this extra content don’t submit these extra

classes – we need a clean version that stays within scope that we can mark precisely!

(you will not be awarded extra marks for doing this.)

8. Will you post an example solution? Yes. Once we have all the submissions and have

completed the marking. This might be a while after the deadline (people get

extensions for being ill etc.) so please be patient! We will devote an examples class to

going over our model solution.