IOOP LAB HASHMAP ARRAY CLASSES PLEASE HELP ZUUL Project REFERENCE BOOK : OBJECTS

ID: 3567006 • Letter: I

Question

IOOP LAB HASHMAP ARRAY CLASSES PLEASE HELP ZUUL Project

REFERENCE BOOK : OBJECTS FIRST WITH JAVA

Game Class

public class Game
{
private Parser parser;
private Room currentRoom;

/**
* Create the game and initialise its internal map.
*/
public Game()
{
createRooms();
createItems();
parser = new Parser();
}

/**
* Create all the rooms and link their exits together.
*/
private void createRooms()
{
Room outside, theater, pub, lab, office;

// create the rooms
outside = new Room("outside the main entrance of the university");
theater = new Room("in a lecture theater");
pub = new Room("in the campus pub");
lab = new Room("in a computing lab");
office = new Room("in the computing admin office");

// initialise room exits
outside.setExit("east", theater);
outside.setExit("south", lab);
outside.setExit("west", pub);

theater.setExit("west", outside);

pub.setExit("east", outside);

lab.setExit("north", outside);
lab.setExit("east", office);

office.setExit("west", lab);

currentRoom = outside; // start game outside
}



private void createItems()
{
Items roomItems;
roomItems = new Items("blah");
// create the

// initialise room items
roomItems.setItem("egg", "theater");
roomItems.setItem("hammer", "lab");
roomItems.setItem("waffle", "pub");

roomItems.setItem("toast", "outside");

roomItems.setItem("bacon", "outside");

roomItems.setItem("spoon", "outside");
roomItems.setItem("fork", "office");

roomItems.setItem("knife", "lab");

//currentRoom = outside; // start game outside
}

/**
* Main play routine. Loops until end of play.
*/
public void play()
{
printWelcome();

// Enter the main command loop. Here we repeatedly read commands and
// execute them until the game is over.

boolean finished = false;
while (! finished) {
Command command = parser.getCommand();
finished = processCommand(command);
}
System.out.println("Thank you for playing. Good bye.");
}

/**
* Print out the opening message for the player.
*/
private void printWelcome()
{
System.out.println();
System.out.println("Welcome to the World of Zuul!");
System.out.println("World of Zuul is a new, incredibly boring adventure game.");
System.out.println("Type 'help' if you need help.");
System.out.println();
System.out.println(currentRoom.getLongDescription());
}

/**
* Given a command, process (that is: execute) the command.
* @param command The command to be processed.
* @return true If the command ends the game, false otherwise.
*/
private boolean processCommand(Command command)
{
boolean wantToQuit = false;

if(command.isUnknown()) {
System.out.println("I don't know what you mean...");
return false;
}

String commandWord = command.getCommandWord();
if (commandWord.equals("help")) {
printHelp();
}
else if (commandWord.equals("go")) {
goRoom(command);
}
else if (commandWord.equals("quit")) {
wantToQuit = quit(command);
}
else if (commandWord.equals("item")) {
item(command);
}
// else command not recognised.

return wantToQuit;
}

// implementations of user commands:

/**
* Print out some help information.
* Here we print some stupid, cryptic message and a list of the
* command words.
*/
private void printHelp()
{
System.out.println("You are lost. You are alone. You wander");
System.out.println("around at the university.");
System.out.println();
System.out.println("Your command words are:");
parser.showCommands();
}

/**
* Try to in to one direction. If there is an exit, enter the new
* room, otherwise print an error message.
*/
private void goRoom(Command command)
{
if(!command.hasSecondWord()) {
// if there is no second word, we don't know where to go...
System.out.println("Go where?");
return;
}

String direction = command.getSecondWord();

// Try to leave current room.
Room nextRoom = currentRoom.getExit(direction);

if (nextRoom == null) {
System.out.println("There is no door!");
}
else {
currentRoom = nextRoom;
System.out.println(currentRoom.getLongDescription());
}
}

private void item(Command command)
{
if(!command.hasSecondWord()) {
// if there is no second word, we don't know where to go...
System.out.println("Do what with the item");
return;
}
String strItem = command.getSecondWord();
// Try to leave current room.
//Room nextRoom = currentRoom.getExit(direction);

if (strItem == null) {
System.out.println("There is no item!");
}
else if(strItem.equals("take")){
System.out.println("took item");
//add item to backpack
}
else if(strItem.equals("drop")){
System.out.println("dropped item");
//drop item
}
}

/**
* "Quit" was entered. Check the rest of the command to see
* whether we really quit the game.
* @return true, if this command quits the game, false otherwise.
*/
private boolean quit(Command command)
{
if(command.hasSecondWord()) {
System.out.println("Quit what?");
return false;
}
else {
return true; // signal that we want to quit
}
}
}

Items Class

import java.util.Set;
import java.util.HashMap;

/**
* Class Room - a room in an adventure game.
*
* This class is part of the "World of Zuul" application.
* "World of Zuul" is a very simple, text based adventure game.
*
* A "Room" represents one location in the scenery of the game. It is
* connected to other rooms via exits. For each existing exit, the room
* stores a reference to the neighboring room.
*
* @author Michael Klling and David J. Barnes
* @version 2011.08.08
*/

public class Items
{
private String description;
private HashMap items; //items in the room.

public Items(String description)
{
//this.description = description;
items = new HashMap();
}

public void setItem(String item, String room)
{
items.put(item, room);
}

public void getItem(String room, String item)
{
items.remove(item);
// backpack.put(item, backpack);
}




}

ROOM CLASS

import java.util.Set;
import java.util.HashMap;

public class Room
{
private String description;
private HashMap exits; // stores exits of this room.

/**
* Create a room described "description". Initially, it has
* no exits. "description" is something like "a kitchen" or
* "an open court yard".
* @param description The room's description.
*/
public Room(String description)
{
this.description = description;
exits = new HashMap();
}

/**
* Define an exit from this room.
* @param direction The direction of the exit.
* @param neighbor The room to which the exit leads.
*/
public void setExit(String direction, Room neighbor)
{
exits.put(direction, neighbor);
}

/**
* @return The short description of the room
* (the one that was defined in the constructor).
*/
public String getShortDescription()
{
return description;
}

/**
* Return a description of the room in the form:
* You are in the kitchen.
* Exits: north west
* @return A long description of this room
*/
public String getLongDescription()
{
return "You are " + description + ". " + getExitString();
}

/**
* Return a string describing the room's exits, for example
* "Exits: north west".
* @return Details of the room's exits.
*/
private String getExitString()
{
String returnString = "Exits:";
Set keys = exits.keySet();
for(String exit : keys) {
returnString += " " + exit;
}
return returnString;
}

/**
* Return the room that is reached if we go from this room in direction
* "direction". If there is no room in that direction, return null.
* @param direction The exit's direction.
* @return The room in the given direction.
*/
public Room getExit(String direction)
{
return exits.get(direction);
}
}

Parsar Class

import java.util.Scanner;

/**
* This class is part of the "World of Zuul" application.
* "World of Zuul" is a very simple, text based adventure game.
*
* This parser reads user input and tries to interpret it as an "Adventure"
* command. Every time it is called it reads a line from the terminal and
* tries to interpret the line as a two word command. It returns the command
* as an object of class Command.
*
* The parser has a set of known command words. It checks user input against
* the known commands, and if the input is not one of the known commands, it
* returns a command object that is marked as an unknown command.
*
* @author Michael Klling and David J. Barnes
* @version 2011.08.08
*/
public class Parser
{
private CommandWords commands; // holds all valid command words
private Scanner reader; // source of command input

/**
* Create a parser to read from the terminal window.
*/
public Parser()
{
commands = new CommandWords();
reader = new Scanner(System.in);
}

/**
* @return The next command from the user.
*/
public Command getCommand()
{
String inputLine; // will hold the full input line
String word1 = null;
String word2 = null;

System.out.print("> "); // print prompt

inputLine = reader.nextLine();

// Find up to two words on the line.
Scanner tokenizer = new Scanner(inputLine);
if(tokenizer.hasNext()) {
word1 = tokenizer.next(); // get first word
if(tokenizer.hasNext()) {
word2 = tokenizer.next(); // get second word
// note: we just ignore the rest of the input line.
}
}

// Now check whether this word is known. If so, create a command
// with it. If not, create a "null" command (for unknown command).
if(commands.isCommand(word1)) {
return new Command(word1, word2);
}
else {
return new Command(null, word2);
}
}

/**
* Print out a list of valid command words.
*/
public void showCommands()
{
commands.showAll();
}
}

Command Words Class

/**
* This class is part of the "World of Zuul" application.
* "World of Zuul" is a very simple, text based adventure game.
*
* This class holds an enumeration of all command words known to the game.
* It is used to recognise commands as they are typed in.
*
* @author Michael Klling and David J. Barnes
* @version 2011.08.08
*/

public class CommandWords
{
// a constant array that holds all valid command words
private static final String[] validCommands = {
"go", "quit", "help", "item"
};

/**
* Constructor - initialise the command words.
*/
public CommandWords()
{
// nothing to do at the moment...
}

/**
* Check whether a given String is a valid command word.
* @return true if it is, false if it isn't.
*/
public boolean isCommand(String aString)
{
for(int i = 0; i < validCommands.length; i++) {
if(validCommands[i].equals(aString))
return true;
}
// if we get here, the string was not found in the commands
return false;
}

/**
* Print all valid commands to System.out.
*/
public void showAll()
{
for(String command: validCommands) {
System.out.print(command + " ");
}
System.out.println();
}
}

Command Class

public class Command
{
private String commandWord;
private String secondWord;

/**
* Create a command object. First and second word must be supplied, but
* either one (or both) can be null.
* @param firstWord The first word of the command. Null if the command
* was not recognised.
* @param secondWord The second word of the command.
*/
public Command(String firstWord, String secondWord)
{
commandWord = firstWord;
this.secondWord = secondWord;
}

/**
* Return the command word (the first word) of this command. If the
* command was not understood, the result is null.
* @return The command word.
*/
public String getCommandWord()
{
return commandWord;
}

/**
* @return The second word of this command. Returns null if there was no
* second word.
*/
public String getSecondWord()
{
return secondWord;
}

/**
* @return true if this command was not understood.
*/
public boolean isUnknown()
{
return (commandWord == null);
}

/**
* @return true if the command has a second word.
*/
public boolean hasSecondWord()
{
return (secondWord != null);
}
}

Player Class

public class Player
{
// instance variables - replace the example below with your own
private String player;

/**
* Constructor for objects of class Player
*/
public Player()
{

}

public void namePlayer(String secondWord)
{
player = secondWord;
}
/**
* An example of a method - replace this comment with your own
*
* @param y a sample parameter for a method
* @return the sum of x and y
*/

}

public class Game
{
private Parser parser;
private Room currentRoom;

/**
* Create the game and initialise its internal map.
*/
public Game()
{
createRooms();
createItems();
parser = new Parser();
}

theater.setExit("west", outside);

pub.setExit("east", outside);

lab.setExit("north", outside);
lab.setExit("east", office);

office.setExit("west", lab);

currentRoom = outside; // start game outside
}



private void createItems()
{
Items roomItems;
roomItems = new Items("blah");
// create the

// initialise room items
roomItems.setItem("egg", "theater");
roomItems.setItem("hammer", "lab");
roomItems.setItem("waffle", "pub");

roomItems.setItem("toast", "outside");

roomItems.setItem("bacon", "outside");

roomItems.setItem("spoon", "outside");
roomItems.setItem("fork", "office");

roomItems.setItem("knife", "lab");

//currentRoom = outside; // start game outside
}

/**
* Main play routine. Loops until end of play.
*/
public void play()
{
printWelcome();

if(command.isUnknown()) {
System.out.println("I don't know what you mean...");
return false;
}

// implementations of user commands:

String direction = command.getSecondWord();

// Try to leave current room.
Room nextRoom = currentRoom.getExit(direction);

Re-factor the Zuul project to have an Item class and a Player class. Use these classes to implement the functionality described in section 6:12. Each room must be able to hold multiple items. The player can pick up an item horn its current room. The player can later drop this item in another room. Implement a Backpack class. The player can use a backpack to carry (hold) multiple items.

Explanation / Answer

have to have the other classes

Navigate

IONS Cuat.2 g the appropria vervt maxdla es 9 to 10 aneous be CHAPTER 3/THE TOOT

IOR PRINTER VERSION | BACK NEXT Brief Exercise 20-5 Your answer is partially cor

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.

IOOP LAB HASHMAP ARRAY CLASSES PLEASE HELP ZUUL Project REFERENCE BOOK : OBJECTS

Question

Explanation / Answer

Related Questions

Navigate