Project #7	CMSC 131
Due:  Dec. 10, 2012 before 11:00PM	Object-Oriented Programming I
Type of Project: CLOSED	Fall 2012

Fish versus Plants

 

 

Project rules:

·         Each fish travels in one direction until it encounters a rock, at which point it turns randomly to move in a direction where there is no rock.  Plants and rocks don't move.

·         The "pond" is created with rocks all around the edge, so you know the fish can't swim out of the pond.

·         If one fish runs into another fish, the larger one eats the smaller one, accumulating it's mass.

·         If a fish passes over a plant, it eats part of the plant -- the fish gets bigger; the plant gets smaller (or disappears if it was already pretty small.)

·         Over time, fish shrink (unless they eat something) and plants grow (unless something eats them).

·         If a fish gets too big, it will explode, creating 4 to 8 smaller fish.  The combined mass of the smaller fish is equal to the mass of the original.

·         If a plant gets too big, it will explode creating 2 to 9 smaller plants.  The combined mass of the smaller plants is equal to the mass of the original.

·         If the size of a fish or a plant reaches zero, it is gone forever.

 

Objectives

To practice:

• exception handling;
• using the ArrayList class;
• using for-each loops;
• more practice using two-dimensional arrays.
• good programming and project management techniques;

 

Overview

Fish versus Plants is a simulation of a very primitive "Ecosystem." 

If you watch Fish versus Plants in "slow motion", you can see some interesting interactions and patterns occurring among the pond's inhabitants.  If you slide the speed slider all the way to the right (maximum speed) and watch patiently, you may observe some interesting long-term patterns in the populations and locations of the fish and plants.  The interactions can be very complex!  It's fun to try to formulate "theorems" for what sorts of situations will yield an "ecosystem" that can survive for a very long time.  Can you think of any scenarios where you can PROVE that the fish will never die?

You will be implementing portions of the data Model as well as all the methods in the Fish and Plant classes. We have distributed skeleton versions of these classes to your CVS repositories -- look in the package called "fishPond".

Hint to understanding  the implementation: The Model contains a "landscape", a "fish" and a "plants".  The landscape is an array where each element of the array is either a ROCK or WATER.  The fish and plants are two separate ArrayLists one to hold the list of fish and the other to hold the list of plants currently pictured in that landscape.  Even though the fish and the plants appear to be in the landscape when you run the controller, the landscape (the array itself) does not contain the fish or the plants.

NOTE: the main method which runs the project is in the Controller class.

 

 

Specifications

See the JavaDoc for a complete description of the project.   This information is also duplicated in the source code distribution that you have received.  A few items of great importance:

• Your work implementation must go in the "fishPond" package.  The tests (public and student) are in the "fishTesting" package.
• There are a few private methods that you must implement, but that are not described in the JavaDoc -- please see the instructions embedded in the source code distribution!
• Please note that reading one of the "Summaries" in the JavaDoc does not show you all of the information about that particular member -- you have to read the full descriptions of each member to see all of your instructions!  (Or read the comments in the source code files.)

 

Style Hint

We have provided a  lot of built-in named constants.  For example, the two-dimensional array that keeps track of where all the rocks are uses the values "Model.ROCK" and "Model.WATER" to keep track of where there are rocks and where there is just water.  Even though you can easily see that these constants represent the values "true" and "false", it is a HUGE mistake to simply use "true" and "false" in your code when differentiating between rock and water.  That defeats the entire purpose of using symbolic constants:  the symbolic constants make the code more readable, and also facilitate possible changes to the project design at some later time.  You will lose style points if you don't use symbolic constants properly!

 

Requirements

• As with all programming assignments:
• You must use meaningful variable names and good indentation.
• You must avoid code duplication, by calling appropriate methods (rather than cutting and pasting code).
• Because we are using an automatic testing system, it is important the you adhere closely to the specifications. In particular, please do not change the names of any of the classes you are to implement, and use the signatures given above for your methods.
• You are encouraged to use for-each loops as much as possible when cycling through the elements in your ArrayLists. 
• Make sure you are aware of the restrictions of what can and can't be done using a for-each loop.
• You must use Random131.getRandomInteger(), and not Java's built-in random number generator, for all random numbers. If you don't use this, most of the tests will fail.
• Follow the instructions provided in the JavaDoc very carefully! If you don't follow them precisely, you will not pass most tests.