SWE 2410, Lab 6: Observing Coconuts

In this lab and the next you will implement a simple game in which coconuts fall on a beach and a crab tries to shoot them down with its laser eyes. You will use the Observer Pattern in your implementation. This is a group lab.

The crab sits on the beach and moves right and left. Coconuts are introduced at the top and fall downwards. The intended rules for the game are that the crab would shoot lasers straight up at coconuts, destroying them. The laser beam should move slowly enough the user can see it move and the crab can move to the side to escape being hit if the laser misses. You might add a random probability for the laser destroying the coconut. The number of coconuts destroyed by a laser beam are counted, as are the number of coconuts reaching the beach. If a coconut hits the crab, no more coconuts are generated. The game ends after the crab is destroyed and all remaining coconuts have hit the beach. The game starts when the user presses the space bar. If the game is already running, pressing the space bar pauses it, and then pressing it again resumes game play. The recommendation is that the up arrow key would fire the laser, but alternatives are acceptable.

You are being given an initial implementation of the game, either through GitHub Classroom or coconuts.zip. You may change most of the elements you are given, but preserve the following:

• Do not change the keystrokes or their effect. Right and left arrows move the players object and space starts/pauses/resumes.

• Beach, Coconut, Crab, IslandObject, HittableIslandObject, LaserBeam, and Sky are all domain classes. All IslandObject instances implement the following operations that can be used to detect which type of object is which type:

    public boolean isHittable();      // is object hittable by any other object
    protected int hittable_height();  // the y coordinate where it can be hit
    public boolean isGroundObject();  // does the object exist on the ground
    public boolean isFalling();       // is the object one that falls
    public void step();               // make the object move one step
    public boolean canHit(IslandObject other); // can this hit other?
    public boolean isTouching(IslandObject other); // is this object touching the other object?

• Feel free to change which classes are derived from HittableIslandObject. If you find it helpful to add additional abstract classes, feel free.

• Objects are considered to be “touching” (that is, colliding) if the appropriate y values are the same and the center of one object is between the left and right coordinates of the other. For falling objects, the appropriate y value is the bottom of the object. For the crab, beach, and laser, the y value is the top.

• All IslandObject instances have an ImageView capturing how to display the item. To move an object, change the x and y values and then call display. These classes (or other domain classes) should not interact with JavaFX in any other way.

• Methods like isGroundObject make it possible to determine which objects represent things like being a crab or a falling coconut. You can change these methods, but keep the basic concept: having these methods mean you do not need to call instanceof in your code. Using instanceof is a poor design decision that comes close to content cohesion since it’s based on Java implementation features rather than domain-level concepts. Do not use instanceof in your code.

• Sky is essentially the game controller. It could probably have a better name. This class may interact more with JavaFX, but the interactions are limited.

• BeachController is the JavaFX controller. Note how the Sky class does most of the work, keeping this controller “thin”. You can modify the code in this class, but keep most of the game play functionality in the Sky and domain classes.

• You may adjust the constants controlling how fast objects move.

There are likely other things you need to know about the provided code; ask!

Implementing the Observer Pattern

The provided code implements little related to one object hitting another. Use the observer pattern to implement this. This will mean writing a subject class capturing hit events and at least one observer class responding to hit events. You will likely find it helpful to distinguish between different hit events. In general, classes observe hit events by displaying information or making objects disappear from the island. Feel free to pass additional data to the update operation.

At a minimum, you must use the observer pattern for the following:

• To display score information. Add a panel to the form for scores and display the number of coconuts shot down and the number of coconuts that hit the beach.
• To make crabs and coconuts disappear from the screen.

There is a fair bit of leeway in how you apply the Observer Pattern in this lab. So a question you might have is whether you are successfully applying the pattern. Look for the following:

• Following best practices, it is good to have a Subject interface that includes the primary methods: attach, detatch, and notifyAll and an Observer interface for update.
• Observers should be calling attach, and updates should happen through the notifyAll method.
• The observer’s update operation should be doing the primary work that happens in response to the state change captured by the subject.

Additional Elements

Your instructor may provide small amounts of extra credit for additional features. See Canvas.

There is a coconut tree picture in the images folder. Feel free to add it to the game screen along with other elements. Important: keep the images in the images folder to minimize problems for your instructor when they try to run your code.

Submission

You will have two weeks to work on this lab. Your instructor may specify deliverables in the first week. In the second week, you will need to submit a Minimal Solution Diagram showing how you applied the pattern, discussion about your experiences with the pattern, and screen shots showing your game in various stages.

Frequent Problems and Questions

• Feel free to change the names of existing classes.
• Make sure the implementations of isHittable, isGroundObject, isFalling, canHit, and other IslandObject methods are correct for each class.
• Make sure you are using operations like isHittable and isGroundObject instead of instanceof. instanceof is an example of content coupling. You may find it helpful to add additional predicates to your hierarchy.
• Do not forget that the upper left corner of every Node (including ImageView) is 0,0. This means y=0 is the top of an image. This is important when writing isTouching. You may find it helpful to write a targetY method that defines where an object touches another.