Java代写｜Object-Oriented Programming Software Assignment 3: Maps

本次英国代写是一个Java编程开发的assignment

1 Introduction

The Colossal Adventure Game is a text-based game that was developed in the
1970s. In the game, the player controls a character through simple text com
mands to explore a cave rumored to be filled with wealth. Players earn predeter
mined points for acquiring treasure and escaping the cave alive, with the goal to
earn the maximum number of points offered.

You must complete the implementation of a version of this game where a
player can type the direction that they would like to go in and the application
must respond accordingly. For example, a player can request “I want to go
north” and the application must determine whether they can go North — based
on direction / location .txt files. If they are able to go North then the application
should allow the player to go North, then list the next set of directions (North,
North East, West, etc) that are available to the player to navigate. This mapping
from one direction to the next, depending on where the player wants to go,
continues until the player quits the game, reaches a dead end and cannot
return, or locates the pot of gold.

If you want to consider the game as follows: there is a house with a variety
of rooms. If you are in the kitchen you may then be able to go north to the
dining room or south to the lounge. You may be able to also go west to the
bathroom. If a player chooses to go north (from the kitchen) to the dining room
they can then go south again and return to the kitchen or perhaps navigate east
to a bedroom.

The beauty about the development of such a game in the 70s was the
player’s ability to type a variety of text, where the application “picks up” only the
direction and ignores the other part of the phrase. This was considered to be
very sophisticated “in its day.”

Descriptions of the overall requirements are given in §4 Coding tasks and
§5.1 Code requirements, but specifics of these requirements are generally left
to ‘TODO’ comments in the skeleton code (use IntelliJ’s TODO tab). You also
need to analyse differences between your version’s output against a set of
ExpectedOutput files provided in the assignment pack.

2 Important points

Starting your assignment by typing code will go wrong and waste a lot of time.
We recommend the following approach:

1. read this document quickly to see the big picture;

2. load the skeleton code into IntelliJ and use these plugins:

Call Graph (Chentai Kao) to visualise which methods call each other,

SequenceDiagram (VanStudio) for a different visualisation of methods
calling each other,

UMLGenerator (Alessandro Caldonazzi) to visualise class relationships;

3. study those diagrams even though they are of incomplete code and think
what extra connections and sequences your completed code will probably
need based on the assignment requirements;

4. study and understand the names of methods and constants and decide
when and how the author intended them to be used;

5. analyse the relationship between the provided input files and their corres
ponding expected output, as this helps you decide and design the steps
needed to convert input to output;

6. study IntelliJ’s TODO tab and relate the list to the assignment requirements;

7. re-read this assignment document in more detail for the requirements and
relate the information to the TODO list, the expected outputs (from their
respective inputs), and the diagrams;

8. put multiple designs on paper and consider which parts of which designs
are more (or less) suitable — be creative here and consider attempting
tasks ‘backwards’ or from an opposing perspective;

9. transform parts of your design into Java code, probably starting with
something from the final stages (for example printing some calculated
output) and working forwards (for example towards the raw inputs needed
to produce that calculated output);

10. use an end-to-end approach and make something work from beginning to
end for a simple case before making your code more flexible, more robust,
more efficient, or more elegant;

11. re-test your code after every two or three lines you write or change: baby
steps are fastest overall