| Iterative Enhancement |
It is critical that you not try to write all the code at once; as you
write/debug code for some classes, you will learn better how to write it for
other classes.
If you try to write everything at once, you are likely to end up in an
undebuggable swamp of code.
I suggest that you follow the instructions below when tacking the parts of
this assignment.
In preparation for writing Simulton classes, first examine the
Behavior interface.
The update methods in classes descended from Simulton can
construct one or more objects implementing this interface, and delegate
tasks to them to achieve the overall required behavior.
For example, see the StraightBehavior (used by balls when they move)
and the AlarmBehavior (which you will find useful for pulsating
holes that shrink after every 50 updates).
Beside these, I wrote the following classes for this assignment; each
implements a Behavior (some of which have extra methods, beyond
doIt as appropriate).
- RemoveBehavior, which takes a Decision parameter, and
whose doIt method removes all objects for which the isOK
method returns true (another method in this class returns a
SimpleQueue of all the objects just removed).
- StarveBehavior, which takes a Simulton and int
parameter and whose doIt method sets an alarm to ring at the
interval specified by the int; whenever the alarm rings,
the size of the simulton is reduced.
Here are alternatives to StraightBehavior for moving objects.
- FloatBehavior, which takes a MoveableSimulton and two
ints (min and max speed) and whose doIt method sets
implements the floating specified above, keeping the speeds between
these extremes.
- PursueBehavior, which takes a MoveableSimulton and a
Decisions and whose doIt method finds the closest
simulton for which the decisions isOK returns true
and sets its angle to point towards it.
Note that I used the atan2 method in the Math class
(NOT atan, whose single parameter does not work as well).
The main idea here is that each update for a method can mix together
various behaviors, keeping its body quite simple by delegating to these
behaviors.
When you create your own special class, you might find it useful to
define yet other classes that implement the Behavior interface.
You are encouraged to continue in this manner.
Many of the behavior classes are quite generic, taking Decision
parameters that embody necessary details, so you'll also be writing
classes that implement this interface (possibly you'll find it useful
to define anonymous ones).
Useful operations inside the isOK methods in these classes are the
instanceof operator and the distance method (on Point
arguments).
You might find it neccessary to declare and initialize interesting instance
variables in classes that implement this interface.
To actually start this assignment, first stub in all the methods in the
Model class and implement the minimal code for adding Ball
objects to the model in the mouseClick method.
All this code will primarily deal with storing an array of Simulton
objects, to which objects can be added and removed.
You should actually write initial versions of most of the useful
Model methods here (some will be enhanced later): I wrote bodies
for just methods 1 and 3-7 here.
Test this code and ensure it is working (you should be able to add/remove
Ball objects to the simulation) before continuing, since I have
already written this class.
Next, write the BlackHole class (study Ball first to understand
how it works) and add it, and any classes that is uses (which implement the
Behavior interface) to the project.
After implementing this class, you must also define the
getAllSatisfying and remove methods in Model and
write nextObject and update mouseClick so that they work
together to coordinate selecting and constructing different kinds of
objects.
Test the interactions between BlackHole and Ball objects.
Next, write the Floater class and add it, and any classes that is uses
(which implement the Behavior interface) to the project.
If you have trouble using the Icon class, first test it behavior
using a ColoredCircle.
After implementing this class, you must update mouseClick
to construct this kind of object and add it to the simulation too.
Test the interactions between BlackHole and Floater objects.
Next, write the PulsatingBlackHole class and add it, and any classes
that is uses (which implement the Behavior interface) to the project.
After implementing this class, you must update mouseClick
to construct this kind of object and add it to the simulation too.
Test the interactions between PulsatingBlackHole and both the
Ball/Floater objects.
Next, write the HuntingBlackHole class and add it, and any classes
that is uses (which implement the Behavior interface) to the project.
(Hint: A direct approach, and one not difficult to program, is to have this
class extend the abstract MoveableSimulton and just mix in
the required behaviors in its update method.
A more interesting approach is to have this class extend the
abstract MoveableSimulton, and then delegate some of its operation
to a PulsatingBlackHole object, which is already written/debugged.)
After implementing this class, you must update mouseClick to
to construct this kind of object too.
Test the interactions between HuntingBlackHole and
Ball/Floater objects.
Finally, specify and write your own subclass in the hierarchy to animate in
some interesting way.
Update mouseClick to construct this kind of object too (after the
Special button is pressed).
Specify its interesting behavior in the comments at the top of its file, and
ensure that it works correctly.
If you have no good ideas of your own, you might implement any of the the
following ideas:
- ...some kind of moving black hole that splits in two if it eats enough
- ...some kind of pulsating black hole that pulls in prey: affects their
velocity using the standard inverse square law of gravity, maybe
proportional to the size of the back hole (and maybe attracting other
black holes too)
- ...a wormhole that swallows any prey, but immediately spits it out at some
other random wormhole (these can be stationary or moving)
- ...a stationary bouncer that bounces any moving simulton that hits it
(maybe either increasing or decreasing the speed of the simultons that
bounce off of it)
- ...a dodger: prey that tries to run away from holes (see the next item:
holes that hunt in pairs)
- ...multiple hunting holes that cooperate to hunt better.
- ...
When writing subclasses, inherit is much state/behavior as you can and
specify only the required new state/behavior.
Typically I did this by constructing objects from classes that implement
the Behavior interface, and delegating the update method
to call methods in these objects.
|
