Map of The Maze Game Custom Environment Presentation Design and implement a custom environment for your maze game. This requires producing your own unique
Map of The Maze Game Custom Environment Presentation Design and implement a custom environment for your maze game. This requires producing
your own unique hand-drawn map of the maze game environment and changing the
HardCodedData file to reflect the locations and items on your map. At least M (M>=5) locations,
including exactly N (N>=2) shops with a condition M>N, must be included, as well as enough
items to allow for proper testing of the game functionality. For example, there must be sufficient
items to verify that a player cannot collect an item if the weight restriction has been met. Note:
you should not retain the original locations or items from the provided code base in your version
of the game.
Hand-drawn map detailing custom game environment, implemented in the game, with
at least M different locations including exactly N shop(s), and items to allow for full
testing
Item management commands
i. listItems / getItem / dropItem
ii. equipItem / unequipItem
iii. purchaseItem / sellItem
iv. getmazestatus
Implementation of combat sequences between a player and hostile NPCs, including
variable outcomes and the ability to flee.
Implementation of collectable items used to restore a player’s life point
Unit test
Power-point presentation
Individual Work
Individual report containing team details and:
a. User stories for each of the deliverables / milestones
b. Class diagrams for Lab 7 and Lab 8
c. Sequence diagrams for two of the item management commands from different groups. ITECH7201 Software Engineering: Analysis and Design (1907)
Assignment 2
Overview
For this assignment, you will logically extend the functionality of the Maze Game introduced during the
lectures, via the modification of the code base as well as documentation and implementation of various
user stories. This is a paired assignment. However, in case of an exceptional situation (if the number
of students in a group is 3), the group should take special permission from the Lecturer.
Timelines and Expectations
Percentage Value of Task: 20%
Due: Sun, Jun 2, 2019 – 23:55 (week 11)
Minimum time expectation: 20 hours
Learning Outcomes Assessed
The following course learning outcomes are assessed by completing this assessment:
Understand the significance of detailed project planning and control, good communication and
documentation and the use of appropriate tools in order to provide a quality product
Understand the distinction between software engineering and programming, and thus the
distinction between a software configuration and a program.
Understand the methods and techniques involved in designing, implementing and maintaining
an information system, in particular using an object-oriented approach
Understand how unit tests are used during software development to assist in agile programming
techniques such as refactoring
Work together in small teams to complete a fully documented, detailed design and
implementation of a small business information system
Demonstrate skills in designing and implementing an information system
Demonstrate skills in designing Unit tests
Assessment Details
You are required to logically extend the functionality of the Maze Game introduced during lectures, via
the modification of the code base as well as documentation and implementation of various user stories.
You will use the Boost methodology discussed during lectures, which requires the use of pair
programming. All documentation, other than the customized game map, must be completed individually.
The code base provided for this assignment has already implemented the “warm up” and some “sets”.
You will be implementing numerous other “sets” for this assignment using the Boost methodology. The
“warm down” stage is not required.
You are free to take ideas discussed during lectures and implement these in your own version of the
code base provided in Moodle for this assignment.
This assignment will be marked according to the functionality of your code, in addition to the elegance
and extensibility of your design and the quality of your documentation.
CRICOS Provider No. 00103D
ITECH 7201 1907 Assignment-2.docx
Page 1 of 5
Note: It is recommended that you spend some time familiarising yourself with the provided code base
prior to beginning any work on this assignment. You should start by spending some time exploring the
structure of the code to gain an understanding of the roles each class plays within the system and then
complete Lab 7-8.
Assignment Requirements
In Pairs:
1.
Design and implement a custom environment for your maze game. This requires producing
your own unique hand-drawn map of the maze game environment and changing the
HardCodedData file to reflect the locations and items on your map. At least M (M>=5) locations,
including exactly N (N>=2) shops with a condition M>N, must be included, as well as enough
items to allow for proper testing of the game functionality. For example, there must be sufficient
items to verify that a player cannot collect an item if the weight restriction has been met. Note:
you should not retain the original locations or items from the provided code base in your version
of the game.
2.
Implement each of the following deliverables/milestones:
a. functionality as detailed in Lab 7 and Lab 8
b. commands to manage the various item management commands:
i.
listItems, getItem, and dropItem, to allow the listing of all held items, collect a new
item and drop a held item.
ii.
equipItem and unequipItem, to wear / wield a held item, and to stop wearing or
wielding an equipped item.
iii.
purchaseItem and sellItem, to buy an item from a vendor and to sell an item to a
vendor.
iv.
getmazestatus to show the status of the maze (i.e., value of M and N)
Ensure that weight restrictions are not exceeded and that the context for each command is
appropriate. For example, purchasing and selling of items should only occur in a shop.
c.
Basic combat functions, allowing a player to attack or to be attacked by a non-player
character (NPC). A player may flee combat or continue to attack until such time as one
combatant loses all life points. The end result must not be hard-coded, and neither the
hostile NPCs nor player may have their attributes configured in such a way that the final
outcome is pre-determined. Note that combat functions should only be available when the
player is in the presence of a hostile NPC, and combat may take whatever form is
appropriate for your game context rather than being limited to just hits with a weapon.
d.
Collectable items that, when used, restore life points to a player. The number of life points
regained should be determined by the roll of 2 six-sided dice up to the player’s maximum
health. You can elect to allow these to be used during combat if you wish.
3.
Write Three Unit test cases for each of the methods you are developing in this assignment.
You can write the test cases in any Java framework, but Junit is preferred.
4.
Prepare a short Power-point presentation to demonstrate your software/program as if you are
going to sell this software/program to a prospective customer. The Power-point presentation
must contain the following items:
CRICOS Provider No. 00103D
ITECH 7201 1907 Assignment-2.docx
Page 2 of 5
a. A demonstration of the game – how the game play works and how this was implemented.
b. Explanation of the role of design patterns in the game, clearly identifying the functionality
where design patterns have had an impact and how this has occurred.
c. An analysis on the use of a development methodology in creating the game describing how
did this assist, or make the development of the game more complicated.
This presentation will be assessed based on the clarity and accuracy of the explanations and how
clearly it demonstrates an understanding of how the game was coded, the design patterns used and
the impact of using a development methodology.
Individually:
1.
Prepare an individual report, to be submitted as a Word document or a PDF, which includes:
a.
The student number and name of each person on your team (including yourself)
b.
User stories for each of the deliverables/milestones
c.
Class diagrams for Lab 7 and Lab 8
d.
Sequence diagrams for two (2) of the item management commands, taken from separate
groupings (i.e. you will not get credit for both getItem and dropItem as they are both in
group i)
e.
A statement of your own personal contribution to the assignment
f.
A statement of your partner’s contribution to the assignment.
Do not work with your partner or any other person to complete your individual report. These must
be unique and your own work.
Please note that assignments will NOT be marked and zero marks will be allocated if the individual
statements of personal and partner contributions are not submitted.
Submission
Each student must submit a single zip file which contains all assignment files in the Assignment 2
submission box provided in Moodle. Submission files include a photograph or a scanned image of your
hand-drawn map, code for each deliverable/milestone, presentation file, and an individual report
containing your student number, name, your partner’s student number and name, diagrams, user stories
and contribution statements.
CRICOS Provider No. 00103D
ITECH 7201 1907 Assignment-2.docx
Page 3 of 5
Marking Criteria/Rubric
Student ID
Partner ID
Student Name
Partner Name
Pre-Requisites For Marking
Statement of personal contribution and partner’s contribution
Task
Available
Marks
Student
Mark
Paired Tasks
a.
Functionality as detailed in Lab 7 and Lab 8
6
b.
Keeping the provision of taking the values of M and N while the program is in
execution
Hand-drawn map detailing custom game environment, implemented in the game, with
at least M different locations including exactly N shop(s), and items to allow for full
testing
6
Item management commands:
3
3
3
3
c.
d.
i.
ii.
iii.
iv.
listItems / getItem / dropItem
equipItem / unequipItem
purchaseItem / sellItem
getmazestatus
6
e.
Implementation of combat sequences between a player and hostile NPCs, including
variable outcomes and the ability to flee.
5
f.
Implementation of collectable items used to restore a player’s life points
5
g.
Unit test
15
15
h. Power-point presentation
Individual Work
Individual report containing team details and:
a.
User stories for each of the deliverables / milestones
10
b.
Class diagrams for Lab 7 and Lab 8
10
c.
Sequence diagrams for two of the item management commands from different groups.
10
Total
100
The percentage value of the Task
20%
CRICOS Provider No. 00103D
ITECH 7201 1907 Assignment-2.docx
Page 4 of 5
Feedback
A completed marking guide will be uploaded in Moodle and marks uploaded to fdlGrades within 2 weeks
of assignment submission.
Plagiarism:
Plagiarism is the presentation of the expressed thought or work of another person as though it is one’s
own without properly acknowledging that person. You must not allow other students to copy your work
and must take care to safeguard against this happening. More information about the plagiarism policy
and procedure for the university can be found at http://federation.edu.au/students/learning-andstudy/online-help-with/plagiarism.
CRICOS Provider No. 00103D
ITECH 7201 1907 Assignment-2.docx
Page 5 of 5
Lab week 7 – Implementing Move in the MazeGame
Explore the codebase
1. Download the “Lab 7” code (this code was discussed in the lecture and has implemented the startup
use case).
2. Unzip the code and open up the solution in Eclipse by performing the following steps.
a. Open Eclipse
b. Open the file menu and click import . . .
c.
From the dialog box
i. Open the “general” tab
ii. Click “Existing Projects into Workspace”
iii. Click next
d. Click “browse” and navigate that holds the lab 7 code
i. The folder ABOVE the bin and src folders
ii. Make sure the check box is clicked in the “projects” text box
iii. Click “finish”
e. The project should now appear in the “projects explorer” pane on the left of Eclipse
3. Spend some time exploring the code, change the startup location in the HardCodedData class and
run the project to test the results.
4. Create an Enterprise Architect project called Lab 7 and reverse engineer the code to create class
diagrams.
Creating a command parser
Before we can get started on implementing commands and adding further functionality to the Maze Game
we need a way of breaking up the user input. Commands have a format of command i.e.:
move west
So what we need to do is break up our user input from a single string into a number of words, and work out
which are commands and which are arguments. We can assume that the first word encountered in user
input is the command, and what follows are the argument(s). We could even make our command parser a
little more user friendly by dropping off commonly used words that are neither commands nor useful
arguments. ie: if the user typed “go to the north” we could drop to and the.
CRICOS Provider No. 00103D
Insert file name here
Page 1 of 9
Let’s start by creating a class to represent our input after it has been parsed into command + arguments.
Create a new class in the Control package called ParsedInput and enter the following:
package mazegame.control;
import java.util.ArrayList;
public class ParsedInput {
private String command;
private ArrayList arguments;
public ParsedInput() {
setArguments(new ArrayList());
setCommand(“”);
}
public ParsedInput(String command, ArrayList arguments){
this.setCommand(command);
this.setArguments(arguments);
}
public String getCommand() {
return command;
}
public void setCommand(String command) {
this.command = command;
}
public ArrayList getArguments() {
return arguments;
}
public void setArguments(ArrayList arguments) {
this.arguments = arguments;
}
}
CRICOS Provider No. 00103D
Insert file name here
Page 2 of 9
Now create a new class called Parser in the same package with the following code:
package mazegame.control;
import java.util.ArrayList;
import java.util.Arrays;
public class Parser {
private ArrayList dropWords;
private ArrayListvalidCommands;
public Parser(ArrayList validCommands){
dropWords = new ArrayList(Arrays.asList(“an”,”and”,”the”,”this”, “to”));
this.validCommands = validCommands;
}
public ParsedInput parse(String rawInput)
{
ParsedInput parsedInput = new ParsedInput();
String lowercaseInput = rawInput.toLowerCase();
ArrayList stringTokens = new
ArrayList(Arrays.asList(lowercaseInput.split(” “)));
for (String token : stringTokens)
{
if (validCommands.contains(token))
{
parsedInput.setCommand(token);
}
else if (!dropWords.contains(token))
parsedInput.getArguments().add(token);
}
return parsedInput;
}
}
So we now have a class which can parse our user input, provided it is given a list of commands when it gets
constructed.
CRICOS Provider No. 00103D
Insert file name here
Page 3 of 9
Incorporating Command handling in the DungeonMaster class
Now that we have a parser we need to put it to work. But before we do that we need to make a small change
to our user interface to accommodate retrieving a command from the player.
Our IMazeClient interface currently has the following two methods declared:
package mazegame.boundary;
public interface IMazeClient {
public String getReply (String question);
public void playerMessage (String message);
}
We could probably use GetReply for the purpose of retrieving commands from a player, but the method is
really designed to ask players a question. So let’s introduce a new method specifically to capture player
commands.
package mazegame.boundary;
public interface IMazeClient {
public String getReply (String question);
public void playerMessage (String message);
public String getCommand();
}
We can now adjust our SimpleConsoleClient class accordingly:
package mazegame;
import java.util.Scanner;
import mazegame.boundary.IMazeClient;
public class SimpleConsoleClient implements IMazeClient {
public String getReply (String question) {
System.out.println(“n” + question + ” “);
Scanner in = new Scanner (System.in);
return in.nextLine();
}
public void playerMessage (String message) {
System.out.print(message);
}
public String getCommand() {
System.out.print (“nn>>>t”);
return new Scanner(System.in).nextLine();
}
}
CRICOS Provider No. 00103D
Insert file name here
Page 4 of 9
Now that our client is setup to retrieve commands from the user we can modify DungeonMaster as follows:
package mazegame.control;
import java.io.IOException;
import java.util.ArrayList;
import
import
import
import
mazegame.SimpleConsoleClient;
mazegame.boundary.IMazeClient;
mazegame.boundary.IMazeData;
mazegame.entity.Player;
public class DungeonMaster {
private IMazeClient gameClient;
private IMazeData gameData;
private Player thePlayer;
private boolean continueGame;
private ArrayList commands;
private Parser theParser;
public DungeonMaster(IMazeData gameData, IMazeClient gameClient) {
this.gameData = gameData;
this.gameClient = gameClient;
this.continueGame = true;
commands = new ArrayList();
commands.add(“quit”);
commands.add(“move”);
theParser = new Parser (commands);
}
public void printWelcome() {
gameClient.playerMessage(gameData.getWelcomeMessage());
}
public void setupPlayer() {
String playerName = gameClient.getReply(“What name do you choose to be known by?”);
thePlayer = new Player(playerName);
gameClient.playerMessage(“Welcome ” + playerName + “nn”);
gameClient.playerMessage(“You find yourself looking at “);
gameClient.playerMessage(gameData.getStartingLocation().getDescription());
// gameClient.getReply(“”);
}
public void runGame() {
printWelcome();
setupPlayer();
while (continueGame) {
continueGame = processPlayerTurn();
}
}
public boolean processPlayerTurn() {
ParsedInput userInput = theParser.parse(gameClient.getCommand());
if (commands.contains(userInput.getCommand())) {
if (userInput.getCommand().equals(“quit”))
CRICOS Provider No. 00103D
Insert file name here
Page 5 of 9
return false;
if (userInput.getCommand().equals(“move”)) {
gameClient.playerMessage(“You entered the move command”);
return true;
}
}
gameClient.playerMessage(“We don’t recognise that command – try again!”);
return true;
}
}
Build your code and run it. You should be able to test it out as follows:
So our game can now interpret commands, but other than quit, it doesn’t really do anything. Furthermore,
our DungeonMaster class is starting to get very messy and may require refactoring. This will be dealt with
next week when we discuss the Command design pattern.
Implementing the Move Player command
Our RAD describes a Move Party User Story:
•
“Move Party – players specify the direction in which they wish their party to move. If an available exit exists in the
direction specified, the system updates the player’s party location and returns a description of the new location”
At this stage we have decided to leave parties out so we rewrite the user story as:
•
“Move Player – players specify the direction in which they wish to move. If an available exit exists in the direction
specified, the system updates the player’s location and returns a description of the new location”
CRICOS Provider No. 00103D
Insert file name here
Page 6 of 9
Let’s implement this user story by first changing the Player class as follows:
package mazegame.entity;
public class Player extends Character {
private Location currentLocation;
public Player() {
}
public Player(String name) {
super (name);
}
public Location getCurrentLocation() {
return currentLocation;
}
public void setCurrentLocation(Location currentLocation) {
this.currentLocation = currentLocation;
}
}
Now we amend the SetupPlayer method in DungeonMaster as follows:
public void setupPlayer() {
String playerName = gameClient.getReply(“What name do you choose to be known by?”);
thePlayer = new Player(playerName);
thePlayer.setCurrentLocation(gameData.getStartingLocation());
gameClient.playerMessage(“Welcome ” + playerName + “nn”);
gameClient.playerMessage(“You find yourself looking at “);
gameClient.playerMessage(gameData.getStartingLocation().getDescription());
// gameClient.getReply(“”);
}
CRICOS Provider No. 00103D
Insert file name here
Page 7 of 9
Next we need to change the Location class so we can retrieve an Exit.
package mazegame.entity;
import java.util.HashMap;
public class Location {
private HashMap exits;
private String description;
private String label;
public Location () { }
public Location (String description, String label) {
this.setDescription(description);
this.setLabel(label);
exits = new HashMap();
}
public boolean addExit (String exitLabel, Exit theExit) {
if (exits.containsKey(exitLabel))
return false;
exits.put(exitLabel, theExit);
return true;
}
public Exit getExit(String exitLabel) {
return (Exit) exits.get(exitLabel);
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public String getLabel() {
return label;
}
public void setLabel(String label) {
this.label = label;
}
}
CRICOS Provider No. 00103D
Insert file name here
Page 8 of 9
Now that we have our Location class setup to retrieve an Exit we can amend the DungeonMaster class to accommodat…
Purchase answer to see full
attachment
