full game code
public class Game
{
private Parser parser;
private Player player;
/**
* Create the game and initialise its internal map.
*/
public Game(String playerName)
{
player = new Player(playerName);
createRooms();
parser = new Parser();
}
/**
* Create all the rooms and link their exits together.
*/
private void createRooms()
{
Room outside, theatre, pub, lab, office, cellar;
Item pint;
// create the rooms
outside = new Room("outside the main entrance of the university");
theatre = new Room("in a lecture theatre");
pub = new Room("in the campus pub");
lab = new Room("in a computing lab");
office = new Room("in the computing admin office");
cellar = new Room("in the cellar");
pint = new Item("pint", "alcholic bvreage", 10);
// initialise room exits
outside.setExit("east", theatre);
outside.setExit("south", lab);
outside.setExit("west", pub);
theatre.setExit("west", outside);
pub.setExit("east", outside);
pub.addItem("pint", pint);
lab.setExit("north", outside);
lab.setExit("east", office);
office.setExit("west", lab);
office.setExit("down", cellar);
cellar.setExit("up", office);
player.enterRoom(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(player.getCurrentRoom().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("look")) {
processLook();
}
// 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 go 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 = player.getCurrentRoom().getExit(direction);
if (nextRoom == null) {
System.out.println("There is no door!");
}
else {
player.enterRoom(nextRoom);
System.out.println(player.getCurrentRoom().getLongDescription());
}
}
/**
* "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
}
}
/**
* "look" was entered. look around the room and print the descripton
* of the room
*/
private void processLook()
{
System.out.println(player.getCurrentRoom().getLongDescription());
}
/**
*try to "pick an item". if that item can be picked.
*keep it.
*/
private void pickItem(Command command)
{
if(!command.hasSecondWord()) {
// if there is no second word, we don't know what item you want
System.out.println("what item");
return;
}
String anItem = command.getSecondWord();
// try to pick the item
player.addItem(anItem);
}
full player code
public class Player
{
// instance variables
private String playerName;
private ArrayList <Item> carriedItems;
private static int MAXWEIGHT = 100;
private double playerWeight;
private Room currentRoom;
/**
* Constructor for objects of class Player
*/
public Player(String name)
{
this.playerName = playerName;
carriedItems = new ArrayList<Item>();
playerWeight = 0;
}
/**
*A method to return the player's name
*/
public String getPlayerName()
{
return playerName;
}
/**
* A method to return the weight of the player by which items
* have added too
*/
public double getPlayerWeight()
{
return playerWeight;
}
/**
* returns the max weight a player can hold
*/
public int getMAXWEIGHT()
{
return MAXWEIGHT;
}
/**
* adds an item
*/
/**
* a method
*/
public Room getCurrentRoom()
{
return currentRoom;
}
/**
* The player enters the room
*/
public void enterRoom(Room nextRoom)
{
currentRoom = nextRoom;
}
/**
* this method will add an item to the player
*/
public void addItem(Item anItem)
{
if(playerWeight + anItem.getItemWeight() <= MAXWEIGHT){
playerWeight = playerWeight + anItem.getItemWeight();
carriedItems.add(anItem);
}else{
System.out.println("the player isnt Strong enough yet to carry this item");
}
}
/**
* this method will remove the item from the player and place the item in that room
*
*/
public void dropItem(Item anItem)
{
carriedItems.remove(anItem);
}
}
full item class
import java.util.HashMap;
/**
* Write a description of class Item here.
*
* @author (your name)
* @version (a version number or a date)
*/
public class Item
{
// instance variables - replace the example below with your own
private String name;
private String description;
private int weight;
/**
* Constructor for objects of class Item
*/
public Item(String name,String description, int weight)
{
this.name = name;
this.description = description;
this.weight = weight;
}
/**
* A method to return the description of the item
*/
public String getDescription()
{
return description;
}
/**
* A method to return the weight of the item
*/
public int getItemWeight()
{
return weight;
}
/**
* A method to return the name of the item
*/
public String getName()
{
return name;
}
/**
* A toString method that prints the details of the
* item as a String.
*/
public String toString()
{
return "Name : " + name +"description : " +description +
"wieght : " +weight;
}
}
and full room code
import java.util.Set;
import java.util.HashMap;
import java.util.Iterator;
/**
* 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 Kolling and David J. Barnes
* @version 2006.03.30
*/
public class Room
{
private String description;
private HashMap<String, Room> exits;// stores exits of this room.
private HashMap<String, Item> items;
/**
* 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<String, Room>();
items = new HashMap<String, Item>();
}
/**
* 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 + ".\n" + getExitString() + ".\n" + getItemString() ;
}
/**
* 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<String> keys = exits.keySet();
for(String exit : keys) {
returnString += " " + exit;
}
return returnString;
}
/**
* returns a string descrbing the items within a room
*/
private String getItemString()
{
String returnString = "Items in the room are:";
Set<String> keys = items.keySet();
for(String item : keys) {
returnString += " " + item;
}
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);
}
/**
* add items to a room
*/
public void addItem(String name, Item object)
{
items.put(name, object);
}
/**
* A method that will remove item's from the hashMap of item's that
* the room holds
*/
public void removeItem(String name)
{
items.remove(name);
}
}
