536 lines
15 KiB
Java
536 lines
15 KiB
Java
/**
|
|
* CS1322: Programming Assignment #2 - Fall 2002
|
|
*
|
|
*
|
|
* <PRE>
|
|
* Class Zoo - A class designed to provide a menu for users to interact
|
|
* with to run the Zoo for P2. This class is provided by CS1322,
|
|
* for you to modify as needed.
|
|
* You should add your collaboration statement, to this ident box below,
|
|
* and place your own @author tag below the one given by the author of
|
|
* the code given.
|
|
* Revisions 1.0: September 15th, 2002
|
|
* Received class from CS1322
|
|
* 1.1: September 28th, 2002
|
|
* Finished Coding
|
|
* </PRE>
|
|
*
|
|
* @author <A HREF="mailto:adhilton@cc.gatech.edu">Andrew Hilton</A>
|
|
* @version Version 1.1, September 28th, 2002
|
|
*/
|
|
import java.io.*;
|
|
public class Zoo
|
|
{
|
|
/**
|
|
* This variable contains all of the buildings (Aquariums and
|
|
* Aviaries) that are in this Zoo.
|
|
*/
|
|
private ZooBuilding[] myBuildings;
|
|
/**
|
|
* This constant specifies the number of buildings in the Zoo.
|
|
*/
|
|
private static final int NUM_BUILDINGS=6;
|
|
/**
|
|
* This constant is the main menu choice for putting a new animal
|
|
* into the Zoo.
|
|
*/
|
|
private static final int CHOICE_PUT_ANIMAL=1;
|
|
/**
|
|
* This constant is the main menu choice for listing the animals
|
|
* in the Zoo.
|
|
*/
|
|
private static final int CHOICE_LIST_ANIMALS=2;
|
|
/**
|
|
* This constant is the main menu choice for feeding the animals in
|
|
* the Zoo.
|
|
*/
|
|
private static final int CHOICE_FEED_ANIMALS=3;
|
|
/**
|
|
* This constant is the main menu choice for moving the net in one
|
|
* of the Aviaries.
|
|
*/
|
|
private static final int CHOICE_MOVE_NET=4;
|
|
/**
|
|
* This constant is the main menu choice for quitting the program.
|
|
*/
|
|
private static final int CHOICE_QUIT=0;
|
|
/**
|
|
* This constant specifies the String that is printed to display the
|
|
* main menu.
|
|
*/
|
|
private static final String MAIN_MENU=
|
|
"Main Zoo Control\n" +
|
|
"----------------\n" +
|
|
CHOICE_PUT_ANIMAL+".) Put an animal in a building\n" +
|
|
CHOICE_LIST_ANIMALS+".) List the animals in a building\n" +
|
|
CHOICE_FEED_ANIMALS+".) Feed the Animals in a building\n" +
|
|
CHOICE_MOVE_NET+".) Move the net in an aviary\n"+
|
|
CHOICE_QUIT+".) Quit\n"+
|
|
"\nEnter your choice: ";
|
|
/**
|
|
* This constant specifies the animal creation menu choice to make a bat.
|
|
*/
|
|
private static final int ANIMAL_BAT=1;
|
|
/**
|
|
* This constant specifies the animal creation menu choice to make a bird.
|
|
*/
|
|
private static final int ANIMAL_BIRD=2;
|
|
/**
|
|
* This constant specifies the animal creation menu choice to make a duck.
|
|
*/
|
|
private static final int ANIMAL_DUCK=3;
|
|
/**
|
|
* This constant specifies the animal creation menu choice to make a gator.
|
|
*/
|
|
private static final int ANIMAL_GATOR=4;
|
|
/**
|
|
* This constant specifies the animal creation menu choice to make a
|
|
* goldfish.
|
|
*/
|
|
private static final int ANIMAL_GOLDFISH=5;
|
|
/**
|
|
* This constant specifies the animal creation menu choice to make a shark.
|
|
*/
|
|
private static final int ANIMAL_SHARK=6;
|
|
/**
|
|
* This constant specifies the String that is displayed for the animal
|
|
* creation menu.
|
|
*/
|
|
private static final String ANIMAL_MENU=
|
|
"Choose an Animal Type:\n"+
|
|
"----------------------\n"+
|
|
ANIMAL_BAT+".) Bat\n"+
|
|
ANIMAL_BIRD+".) Bird\n"+
|
|
ANIMAL_DUCK+".) Duck\n"+
|
|
ANIMAL_GATOR+".) Gator\n"+
|
|
ANIMAL_GOLDFISH+".) Goldfish\n"+
|
|
ANIMAL_SHARK+".) Shark\n"+
|
|
"\nEnter your choice: ";
|
|
/**
|
|
* The default constructor for Zoo.
|
|
* This constructor initializes myBuildings to be an array of
|
|
* size NUM_BUILDINGS, then fills it in, alternating between Aviaries
|
|
* and Aquariums.
|
|
*/
|
|
public Zoo()
|
|
{
|
|
myBuildings=new ZooBuilding[NUM_BUILDINGS];
|
|
for(int i=0;i<myBuildings.length;i++)
|
|
{
|
|
if(i%2==0)
|
|
myBuildings[i]=new Aviary("Aviary number "+(i/2+1));
|
|
else
|
|
myBuildings[i]=new Aquarium("Aquarium number "+ (i/2+1) );
|
|
}//for
|
|
}//Zoo()
|
|
/**
|
|
* Reads user input and creates a specified animal.
|
|
* This method reads in input from the user to determine what
|
|
* type of Animal to make, and then reads the appropriate information
|
|
* for that type of Animal.
|
|
* @return a newly created Animal that matches the user's specifications,
|
|
* or null if the user selects an invalid Animal number
|
|
*/
|
|
private Animal makeAnimalForUser()
|
|
{
|
|
System.out.println(ANIMAL_MENU);
|
|
int choice= readIntFromUser();
|
|
Animal toRet=null;
|
|
String name;
|
|
String species;
|
|
String dangerous;
|
|
boolean isDangerous;
|
|
int depth;
|
|
switch(choice)
|
|
{
|
|
case ANIMAL_BAT:
|
|
name=promptAndRead("Name: ");
|
|
toRet=new Bat(name);
|
|
break;
|
|
case ANIMAL_BIRD:
|
|
name=promptAndRead("Name: ");
|
|
species=promptAndRead("Species: ");
|
|
|
|
do
|
|
{
|
|
dangerous=promptAndRead("Dangerous [Y/N]: ");
|
|
}
|
|
while(!(dangerous.equalsIgnoreCase("Y")||
|
|
dangerous.equalsIgnoreCase("N")));
|
|
isDangerous=dangerous.equalsIgnoreCase("Y");
|
|
toRet= new Bird(name,species,isDangerous);
|
|
break;
|
|
case ANIMAL_DUCK:
|
|
name=promptAndRead("Name: ");
|
|
toRet= new Duck(name);
|
|
break;
|
|
case ANIMAL_GATOR:
|
|
name=promptAndRead("Name: ");
|
|
toRet= new Gator(name);
|
|
break;
|
|
case ANIMAL_GOLDFISH:
|
|
name=promptAndRead("Name: ");
|
|
System.out.print("Depth: ");
|
|
depth=readIntFromUser();
|
|
toRet= new GoldFish(name,depth);
|
|
break;
|
|
case ANIMAL_SHARK:
|
|
name=promptAndRead("Name: ");
|
|
System.out.print("Depth: ");
|
|
depth=readIntFromUser();
|
|
toRet= new Shark(name,depth);
|
|
break;
|
|
default:
|
|
System.out.println("That is not a valid animal type");
|
|
break;
|
|
}
|
|
return toRet;
|
|
}//makeAnimalForUser
|
|
/**
|
|
* This method moves the Animals in all of the buildings around
|
|
* randomly. In addition to moving the Animals around, this method
|
|
* makes Animals become hungry, at random- each with a 75% chance
|
|
* of becoming hungry when this method is called.
|
|
*/
|
|
private void moveAnimalsAround()
|
|
{
|
|
for(int i=0;i<myBuildings.length;i++)
|
|
{
|
|
ZooBuilding zb=myBuildings[i];
|
|
LinkedList ll=zb.getTheAnimals();
|
|
Object[] animalsInList=ll.asArray();
|
|
for(int j=0;j<animalsInList.length;j++)
|
|
{
|
|
|
|
if(animalsInList[j] instanceof FlyingType &&
|
|
animalsInList[j] instanceof SwimmingType)
|
|
{
|
|
//this animal can both swim and fly.
|
|
//better find out where it is
|
|
FlyingType ft=(FlyingType) animalsInList[j];
|
|
SwimmingType st = (SwimmingType) animalsInList[j];
|
|
int alt=ft.getAltitude();
|
|
int depth=st.getDepth();
|
|
boolean swimming;
|
|
if(alt<=0)
|
|
swimming=true;
|
|
else
|
|
swimming=false;
|
|
if(swimming)
|
|
{
|
|
//if near the water's surface, maybe we take off
|
|
//(1/4 chance)
|
|
if(depth<=1 &&Math.random()<0.25)
|
|
{
|
|
st.setDepth(0);
|
|
ft.setAltitude((int)(Math.random()*25)+15);
|
|
}
|
|
else
|
|
{
|
|
int change=(int)((Math.random()*5)-2);
|
|
depth += change;
|
|
st.setDepth(depth);
|
|
}
|
|
}//swimming
|
|
else
|
|
{
|
|
//flying low. maybe we land and swim?
|
|
// (1/4 chance)
|
|
if(alt <=25 && Math.random()<0.25)
|
|
{
|
|
ft.setAltitude(0);
|
|
st.setDepth(1);
|
|
}
|
|
else
|
|
{
|
|
int change=(int)(Math.random()*48)-24;
|
|
alt += change;
|
|
ft.setAltitude(alt);
|
|
}
|
|
}//flying
|
|
}
|
|
else if(animalsInList[j] instanceof FlyingType)
|
|
{
|
|
FlyingType ft=(FlyingType) animalsInList[j];
|
|
int alt=ft.getAltitude();
|
|
int change=(int)((Math.random()*20)+(Math.random()*20)-10);
|
|
alt += change;
|
|
if(alt<0)
|
|
{
|
|
alt=0;
|
|
}
|
|
ft.setAltitude(alt);
|
|
|
|
}//flying
|
|
else if(animalsInList[j] instanceof SwimmingType)
|
|
{
|
|
SwimmingType st=(SwimmingType) animalsInList[j];
|
|
//*** YOUR CODE GOES HERE *** (3)
|
|
int depth = st.getDepth();
|
|
/************/
|
|
|
|
int change=(int)((Math.random()*30)-12);
|
|
depth+=change;
|
|
//*** YOUR CODE GOES HERE *** (4)
|
|
st.setDepth(depth);
|
|
/*****************/
|
|
|
|
}//swimming
|
|
if(animalsInList[j] instanceof Animal)
|
|
{
|
|
if(Math.random()<0.75) //75% chance of animal getting hungry
|
|
{
|
|
((Animal)animalsInList[j]).setIsHungry(true);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
System.err.println("Error: Non-animal in array at index "+
|
|
j+"\n found: "+animalsInList[j]);
|
|
System.exit(-1);
|
|
}
|
|
}//for j
|
|
}//for i
|
|
}//moveAnimalsAround()
|
|
/**
|
|
* A conveinece method to prompt the user for input and read it.
|
|
* Prints the prompt, then reads and returns a line of input.
|
|
* @param prompt is the prompt to print
|
|
* @return the line of input read from the user.
|
|
*/
|
|
private static String promptAndRead(String prompt)
|
|
{
|
|
System.out.print(prompt);
|
|
return IOHelper.readLine();
|
|
}
|
|
/**
|
|
* Reads in an int from the user and returns it.
|
|
* This method reads lines of input from the user until the user enters
|
|
* a valid number. When a valid number is entered, it is converted
|
|
* from a String to an int and returned.
|
|
* @return the number that the user entered.
|
|
*/
|
|
private static int readIntFromUser()
|
|
{
|
|
String line="";
|
|
int choice=0;
|
|
boolean done=false;
|
|
do
|
|
{
|
|
//***YOUR CODE GOES HERE*** (1)
|
|
line = IOHelper.readLine();
|
|
|
|
//now do conversion of line to an int
|
|
try
|
|
{
|
|
choice=Integer.parseInt(line);
|
|
done=true;
|
|
}
|
|
catch(NumberFormatException nfe)
|
|
{
|
|
System.out.println("That was not a number! Try again");
|
|
}
|
|
|
|
}
|
|
while(!done);
|
|
return choice;
|
|
}//readIntFromUser()
|
|
/**
|
|
* Selects a building number.
|
|
* Prompts the user to select a building, continues to reprompt
|
|
* until a valid building number is entered.
|
|
* @return the building number entered by the user
|
|
*/
|
|
private int chooseBuilding()
|
|
{
|
|
int choice;
|
|
do
|
|
{
|
|
System.out.print("Enter a building number");
|
|
choice=readIntFromUser();
|
|
}
|
|
while(choice<0|| choice>=myBuildings.length);
|
|
return choice;
|
|
}//chooseBuilding
|
|
/**
|
|
* Handles putting a new Animal into the Zoo.
|
|
* This method reads input from the user to determine which building the
|
|
* Animal should go into. Then it calls makeAnimalForUser() to
|
|
* create a new Animal to put in. If the Animal cannot live in that
|
|
* type of building, an error is printed and the method returns,
|
|
* otherwise the Animal is added to the building.
|
|
*/
|
|
private void doPutAnimal()
|
|
{
|
|
int buildingNumber=chooseBuilding();
|
|
ZooBuilding zb=myBuildings[buildingNumber];
|
|
Animal toAdd=makeAnimalForUser();
|
|
if(toAdd==null)
|
|
{
|
|
return;
|
|
}
|
|
if(((myBuildings[buildingNumber] instanceof Aviary) &&
|
|
!(toAdd instanceof FlyingType))||
|
|
((myBuildings[buildingNumber] instanceof Aquarium) &&
|
|
!(toAdd instanceof SwimmingType)))
|
|
{
|
|
System.out.println("That animal cannot live in that building!");
|
|
return;
|
|
}
|
|
//***YOUR CODE GOES HERE *** (5)
|
|
zb.getTheAnimals().addToBack(toAdd);
|
|
/**********************************/
|
|
|
|
}//doPutAnimal()
|
|
/**
|
|
* Lists the animals in a building.
|
|
* This method prompts the user for a building number, then
|
|
* lists all of the animals in that building.
|
|
*/
|
|
private void doListAnimals()
|
|
{
|
|
//*** YOUR CODE GOES HERE *** (6)
|
|
int choice = chooseBuilding();
|
|
ZooBuilding zb = myBuildings[choice];
|
|
Animal temp;
|
|
|
|
for(int i=0; i<zb.getTheAnimals().size(); i++){
|
|
temp = (Animal)zb.getTheAnimals().removeFromFront();
|
|
System.out.println(temp);
|
|
zb.getTheAnimals().addToBack(temp);
|
|
}
|
|
}//doListAnimals()
|
|
/**
|
|
* Feeds the Animals in a building.
|
|
* This method prompts the user for a building number and a type of food,
|
|
* then feeds that food to the animals in the specified building.
|
|
*/
|
|
private void doFeedAnimals()
|
|
{
|
|
int buildingNumber=chooseBuilding();
|
|
ZooBuilding zb=myBuildings[buildingNumber];
|
|
String food=promptAndRead("What type of food?");
|
|
//*** YOUR CODE GOES HERE *** (7)
|
|
zb.feedAnimals(food);
|
|
|
|
}//doFeedAnimals()
|
|
|
|
/**
|
|
*prompt for building, check if its aviary,
|
|
*and if it is, add/remove the net
|
|
*/
|
|
private void doMoveNet()
|
|
{
|
|
// *** YOUR CODE GOES HERE *** (9)
|
|
//Let's do this all in Hungarian Notation :)
|
|
//So MS isn't completely useless, eh?
|
|
|
|
String sEntry;
|
|
int iChoice = 0;
|
|
boolean bDone = false;
|
|
|
|
do{
|
|
sEntry = promptAndRead("What building?");
|
|
try
|
|
{
|
|
iChoice=Integer.parseInt(sEntry);
|
|
bDone=true;
|
|
}
|
|
catch(NumberFormatException nfe)
|
|
{
|
|
System.out.println("That was not a number! Try again");
|
|
}
|
|
}while(!bDone);
|
|
|
|
if(!(myBuildings[iChoice] instanceof Aviary)){
|
|
System.out.println("That building is not an Aviary, it has no net");
|
|
return;
|
|
}
|
|
|
|
boolean bNet;
|
|
Aviary avTemp = (Aviary)myBuildings[iChoice];
|
|
bNet = avTemp.getNetClosed();
|
|
|
|
if(bNet){
|
|
avTemp.setNetClosed(false);
|
|
}
|
|
else {//!bNet
|
|
avTemp.setNetClosed(true);
|
|
}
|
|
|
|
}//doMoveNet
|
|
private void showZooStatus()
|
|
{
|
|
System.out.println("Zoo status");
|
|
System.out.println("----------");
|
|
for(int i=0;i<myBuildings.length;i++)
|
|
{
|
|
System.out.println(myBuildings[i]);
|
|
if(myBuildings[i].isSafeToEnter())
|
|
{
|
|
System.out.println("\t Is safe to enter.");
|
|
}
|
|
else
|
|
{
|
|
System.out.println("\t Is NOT safe to enter.");
|
|
}
|
|
System.out.println("\t Has "+myBuildings[i].getHungryAnimals()+
|
|
" hungry animals.");
|
|
}//for i
|
|
}//showZooStatus
|
|
/**
|
|
* Runs the Zoo simulation.
|
|
* This method displays the menu and performs the requested action
|
|
* until the user chooses to quit.
|
|
*/
|
|
private void run()
|
|
{
|
|
int userChoice;
|
|
do
|
|
{
|
|
moveAnimalsAround();
|
|
showZooStatus();
|
|
//***YOUR CODE GOES HERE*** (8)
|
|
System.out.println(MAIN_MENU);
|
|
/****************************/
|
|
|
|
userChoice=readIntFromUser();
|
|
switch(userChoice)
|
|
{
|
|
case CHOICE_PUT_ANIMAL:
|
|
doPutAnimal();
|
|
break;
|
|
case CHOICE_LIST_ANIMALS:
|
|
doListAnimals();
|
|
break;
|
|
case CHOICE_FEED_ANIMALS:
|
|
doFeedAnimals();
|
|
break;
|
|
//*** YOUR CODE GOES HERE *** (10)
|
|
case CHOICE_MOVE_NET:
|
|
doMoveNet();
|
|
break;
|
|
case CHOICE_QUIT:
|
|
/* do nothing */
|
|
break;
|
|
default:
|
|
//***YOUR CODE GOES HERE***(2)
|
|
System.out.println("That is not a valid choice, try again");
|
|
break;
|
|
}//switch(userChoice)
|
|
}
|
|
while(userChoice!= CHOICE_QUIT);
|
|
}//run()
|
|
/**
|
|
* The starting point for the program- makes a new Zoo, and calls
|
|
* run() to do the simulation.
|
|
* @params args IGNORED.
|
|
*/
|
|
public static void main(String[] args)
|
|
{
|
|
Zoo myZoo=new Zoo();
|
|
myZoo.run();
|
|
}//main()
|
|
|
|
}//end class Zoo
|