Wellesley College, Summer 2003 Problem Set 2 Due: Friday, June 20 by 10 am

About this Problem Set

To get the code for this assignment, connect to cs111 download directory via Fetch and download the folder ps2_programs from the directory /cs111d.

Reading

• JEM Examples
• Object-Oriented Programming
• Methods

How to turn in this Problem Set

Hardcopy Submission of Required Problems

1. The cover page;
2. Your Execution Diagram from Task 1;
3. Your modified Writing2.java file from Task 2;
4. Your modified FlowerMaker.java file from Task 3.

Softcopy Submission of Required Problems

Save the modified Writing2.java file in your local version of the Writing2 folder and the the modified FlowerMaker.java file in your local version of the Flowers folder. Submit the entire copy of your ps2_programs folder to your drop folder on the cs111 server.

Hardcopy Submission of Optional Extra Credit Problems

Softcopy Submission of Optional Extra Credit Problems

If you work on the extra credit problem, submit your HuggleWorld folder to your ps2 drop folder on the cs111 server.

Task 1: Java Execution Model

In this part of the homework, you will use the Java Execution Model to draw an Execution Diagram that summarizes the execution of a simple Buggle program. It is important to become familiar with the conventions for drawing Execution Diagrams, since they are an important tool for explaining the behavior of Java programs. In particular, Execution Diagrams explain the meaning of method invocation, parameter passing, local variable declarations, and the this variable. You will be expected to draw an Execution Diagram on your midterm exam.

Before continuing with this problem, please study the conventions for drawing execution diagrams (i.e. your notes from lecture and the reading for this problem set).

Your JEM Assignment

Below are the declarations for two classes: a SwapWorld class that is a subclass of BuggleWorld and a SwapBuggle class that is a subclass of Buggle.

public class SwapWorld extends BuggleWorld {
  public void run () {
    SwapBuggle bg1 = new SwapBuggle();
    SwapBuggle bg2 = new SwapBuggle();
    SwapBuggle bg3 = new SwapBuggle();
    Point pt1 = new Point(6,3);
    Point pt2 = new Point(4,5);
    bg1.setPosition(pt1);
    bg2.setPosition(pt2);
    bg3.setPosition(new Point(pt1.x-pt2.x, pt1.y+pt2.y));
    bg2.setColor(Color.blue);
    bg1.setColor(Color.green);
    bg2.left();
    bg3.right();
    bg2.swap(bg3);
    bg3.swap(bg1);
  }
}
 
class SwapBuggle extends Buggle {
public void swap (Buggle bg1) {
    Point pt1 = this.getPosition();
    Point pt2 = bg1.getPosition();
    Color c1 = this.getColor();
    Color c2 = bg1.getColor();
    this.setPosition(pt2);
    bg1.setPosition(pt1);
    this.setColor(c2);
    bg1.setColor(c1);
  }
}

Suppose that Object Land contains an instance of the SwapWorld class that has the reference label SW1. Your assignment is to draw an Execution Diagram for the execution of the statement

SW1.run()

Please be careful. This code is specifically designed to be tricky in a number of places. Be sure to pay attention to the following:

• You should draw only a single diagram that summarizes the final result of completely executing the above statement.
• Your Execution Land should show all non-black-box execution frames created during the execution. There should be exactly three such frames: one for the invocation of run() and one for each of the two invocations of swap(). Each execution frame should have two parts: (1) a variables section and (2) a statement section. Each variable section should include: (1) a this variable; (2) any parameters declared by the invoked method; and (3) any local variables declared within the body of the invoked method. The statement section should show the result of evaluating all expressions. Each expression should be replaced by a representation of its value.
• Your Object Land should show at least ten objects: the given instance of the SwapWorld class, three instances of the SwapBuggle class, three instances of the Point class, and three instances of the Color class. Label each of your objects in Object Land with a unique reference label (e.g. B1, B2, B3 for the buggles; P1, P2 for the points, etc). It is a bad idea to use reference labels which are the same as any variable names in your code. Use these labels in place of pointers. You need not show any Direction instances in Object Land; use the convention of representing such instances by special reference labels like WEST. Your diagram should show the state of each object after the completion of the execution of the run method.
• You may use the following shortcut for Color objects: you may draw a Color Object blob and write, say, "Color.red" inside the object, rather than writing out the red, green and blue instance variable values.
• It is recommended that you draw your diagram using pencil and paper. Pens make errors difficult to fix. Computer drawing package are usually more trouble than they are worth for this sort of application.
• Please try to make your diagram as neat as possible.

Task 2: Buggle Word Writing using Methods

Your assignment:

In the folder Writing2 is a file Writing2.java that contains Java code that creates a 25x25 grid and defines LetterBuggle, a new class of objects that extends the Buggle class. A new LetterBuggle named ellie has also been created for you, along with the skeleton of two LetterBuggle methods: writeJava, and writeJ, as shown below:

public class Writing2 extends BuggleWorld {

    public void setup () {
        setDimensions(25,25); // magic for making 25x25 grid
    }

    //write the word "JAVA" around the perimeter of the grid
    public void run () {
        LetterBuggle ellie = new LetterBuggle();
        ellie.writeJava(Color.red, Color.blue, Color.yellow);

       // Add statements here that will write the word in various colors 
       // around the perimeter of the grid

     }
}

class LetterBuggle extends Buggle {

    // Write the word "JAVA", in the appropriately colored letters, by 
    // invoking methods with appropriate color parameters for writing the 
    // individual letters. Note that the J and the V are always the same color, 
    // but each A can be a different color from the color of the J and V.
    public void writeJava (Color c1, Color c2, Color c3) {

        this.writeJ(c1);//write the "J" in color c1
        // Add statements to write the "A V A" in the correct colors.

    }

    // write the letter "J" in color c
    public void writeJ (Color c) {

       // Flesh out the body of this method.

    }
		     
    // Define methods for writing "A" and "V" here. 
}

• Flesh ou the writeJ method so that it draws the letter "J". This code should be very similar to the code you used in Problem Set 1 for that purpose! Assume that when you start to write a letter (other than"V"), the buggle is in the lower left square of a 4x5 grid, facing the direction you are writing in. At the end of the method, make sure that the buggle is placed in the correct position and direction to start the next letter (at the lower left square of the next 4x5 grid, separated by one space from the previous letter, facing the direction of writing).
• Note that the writeJ method takes a Color parameter c. Use this parameter inside the body of writeJ to set the color of the Buggle appropriately.
• Define similar methods (each also with a single Color parameter) to write an "A" and a "V". Note that "V" occupies a 3x5 grid instead of the 4x5 grid occupied by each of the other letters.
• Add code to the writeJava method so that it draws the word "JAVA" by invoking the methods which write the individual letters and using the three color parameters correctly.
• Add code to the run method in the Writing2 class so that it draws the word 4 times around the perimeter of the grid, by invoking the writeJava method repeatedly. You will need to make sure that you invoke writeJava with the correct 3 color parameters in the right order to match the given picture (above). You will need to come up with a way to turn and change your heading at each corner of the grid.

1. You may not invoke the setPosition or setHeading methods.
2. You should use the methods brushUp and brushDown where appropriate.
3. Each letter except "V" should fit in a 4x5 grid, and should be separated from the next letter by one blank space.
4. The letter "V should occupy a 3x5 grid as shown.
5. Ellie must draw the letters in the appropriate colors. All the colors used in the picture above are Color constants from the Color class. These constants are only used in the run method. They may not be used anywhere else in your code.
6. Ellie must end up in the position shown above, facing the correct direction (EAST).
7. Use methods to solve the problem.

Task 3: Flowers

Alternatively, to be on the safe side (i.e. to make sure that you are not running the code from the previous task instead of the new one), you might want to quit CodeWarrior entirely and reopen it for the new project. To do this

1. quit CodeWarrior (File -> Quit),
2. quit the Applet Runner by selecting Apple Applet Runner from the menu of active applications in the upper right corner of the screen, then choosing Quit from the File menu,
3. double-click on the FlowerWorld.mcp icon to open the second project

Flora is a turtle who loves flowers. Here is a garden with three flowers that Flora would like to draw:

Flora is an instance of the FlowerMaker class, which extends the Turtle class. In this problem, you will flesh out the following methods in the FlowerMaker class to enable Flora to draw her garden. All code can be found in the file FlowerMaker.java within the Flowers folder.

public void diamond (double side)
Draws a diamond with internal angles of 60 and 120 degrees whose sides have length side. The state of the turtle is left unchanged after drawing the diamond. For instance, if flora is a red turtle facing up, here is the picture drawn by the invocation flora.diamond(100):

public void diamond4 (double side)
Draws four diamonds that fill an outer diamond of side length side. The state of the turtle is left unchanged after drawing the diamonds. For instance, if flora is a red turtle facing up, here is the picture drawn by the invocation flora.diamond4(100):

public void diamond16 (double side)
Draws sixteen diamonds that fill an outer diamond of side length side. The state of the turtle is left unchanged after drawing the diamonds. For instance, if flora is a red turtle facing up, here is the picture drawn by the invocation flora.diamond16(100):

public void flower (double side, Color inner, Color outer)
Draws a flower from the stem up in the direction the turtle is facing. The stem is green and is twice the length of side with two green leaves at its midpoint. The two outer petals consist of four diamonds of color outer fitting into a diamond with side length side. The inner (middle) petal consists of sixteen diamonds f color inner fitting into a diamond with side length side. The state of the turtle is left unchanged after drawing the flower, except for the color, which may be different from the initial color. For instance, if flora is a red turtle facing up, here is the picture drawn by the invocation flora.flower(100, Color.red, Color.blue):

public void garden ()
Assume the turtle is positioned at the middle bottom of the screen facing up. Draws the garden with three flowers pictured at the beginning of this problem description. Here are the details of the three flowers:

1. Directly above the turtle is a flower with a yellow inner petal and red outer petals of side length 100.
2. 250 units to the right of the initial turtle position is a flower with a pink inner petal and blue outer petals of side length 75.
3. 200 units to the left of the initial turtle position is a flower with a magenta inner petal and cyan outer petals of side length 50.

The state of the turtle is left unchanged after drawing the flower, except for the color, which may be different from the initial color.

Your task is to flesh out the skeletons of the five methods in FlowerMaker.java so that they satisfy the method contracts given above.

Notes:

• FlowerWorld is a subclass of BuggleWorld that has already been written for you. It contains a run method that creates an instance of FlowerMaker named flora and positions here in the middle of the bottom of the screen facing up:

  public class FlowerWorld extends TurtleWorld {
      public void run() {
          FlowerMaker flora = new FlowerMaker();
          // position flora near bottom of screen, facing up in middle
          flora.lt(90);
          flora.pu();
          flora.bd(185);
          flora.pd();
          flora.garden();
      }
  }
  

• You are strongly encouraged to flesh out the methods in the order give above. I.e., first write diamond, then diamond4, then diamond16, etc.
  
  
• Since FlowerWorld invokes the garden method on flora, you can use the garden method to test your earlier methods. For instance, to test your diamond method, you can temporarily define the garden method to be:

  public void garden () {
      this.diamond(100);
  }
  

  Similarly, you can use garden to test the diamond4, diamond16, and flower methods. When you are done using garden to test all these methods, you can define garden to do what it's really supposed to do: draw three flowers.

Extra Credit Task 4: HuggleWorld

Background

The Story

Fontaine Buggle is very impressed by the creative work of her cousins at the Buggle Bagel Ruggle Company. But she thinks that buggles can use their considerable talents to do more than just drop bagels in interesting patterns.

Inspired by the buggle writing problem of Problem Set 1 (remember "Java"?), Fontaine wants buggles to be able to write words using letters of any color drawn in rectangles of arbitrary size and orientation. As a simple example of what can be done with this capability, Fontaine designs the following Valentine card:

The card uses the seven letters 'C', 'd', 'G', 'H', 'I', 'P', and 'U'. Note that the 'U' appearing in "CUPId" and "HUG" has the same basic shape even though it is written in rectangles of different sizes (a 5x5 rectangle in the case of the 'U' in "CUPId" and a 7x17 rectangle int the case of the 'U' in "HUG").

Letter Methods and their Contracts

Fontaine recognizes that methods can be used to capture the similarity in shape while abstracting over the color and rectangle size. She defines a new FontBuggle class that is a subclass of Buggle extended with methods that draw the seven letters of the Valentine card. For example, the FontBuggle class has a method for drawing the letter 'U' according to the following contract:

public void U (Color col, int width, int height);

Assume the initial brush state of this buggle is down. Consider the width by height rectangle such that this buggle is in the lower left hand corner facing along the width edge. Executing this method causes this buggle to draw the letter 'U' inscribed in the rectangle, as shown below. The heading of the buggle should not change, but its final position should be width + 1 cells in front of its original position, its final color should be col, and its final brush state should be down.

Fontaine defines similar methods for the other six letters, whose contracts are the same as that for U() except for the shape inscribed in the rectangle. The shapes drawn by the C(), d(), G(), H(), I(), and P() methods are depicted below:

Java Arithmetic

The dimensions in the above pictures are given in terms of Java integer arithmetic. Java integer arithmetic is pretty much what you would expect except that division of two integers always yields the integer that results by truncating (not rounding) the decimal portion of the exact result. For example:

n	n/2	n/3	n/4
5	2	1	1
6	3	2	1
7	3	2	1
8	4	2	2
9	4	3	2

The following equations are also always true (both in Java arithmetic and traditional arithmetic):

The reason that we prefer the left-hand side versions to the right-hand side versions in the above diagram is that the left-hand side versions turn out to be more useful when drawing the letters with buggles. (See the note on fencepost errors in the tasks section, below.)

You should also convince yourself that in Java integer arithmetic, the following equation is always true (this equation is not true for traditional arithmetic!):

Stringing Letters Together

The final position and heading of a FontBuggle after drawing a letter is designed to facilitate stringing letters together to form words. If the FontBuggle is asked to draw a new letter, both letters will be on the same "baseline", and there will be one cell of space between the previous letter and the new one. For example, consider the following method for drawing the word "CUP":

public void CUP () {
  C(Color.blue, 3, 5);
  U(Color.green, 8, 3);
  P(Color.red, 4, 12);
}

Invoking the CUP() method on a FontBuggle causes it to draw the following letters:

Buggle Jumping

Since letters do not always directly follow one another, it is useful to have the following jump() method, which changes the relative position of a FontBuggle by fwd units in the forward direction and lft units to its left. (Either number may be 0 or negative.)

	public void jump (int fwd, int lft) {
	  brushUp();
	  forward(fwd);
	  left();
	  forward(lft);
	  right();
	  brushDown();
	 }

Because the parameters to jump() are relative to the buggle's current position and heading, the method works regardless of the buggle's initial state. After jumping, it is often desirable to turn the buggle; the following three methods abstract over the three possible ways of turning:

	 public void jumpAndTurnLeft (int fwd, int lft) {
	   jump(fwd,lft);
	   left();
	 }
	 
	 public void jumpAndTurnRight (int fwd, int lft) {
	   jump(fwd,lft);
	   right();
	 }
	 
	 public void jumpAndTurn180 (int fwd, int lft) {
	   jumpAndTurnLeft(fwd,lft);
	   left();
	 }

As an example of buggle jumping, consider the following method:

	public void fourCUPs () {
	  CUP();
	  jumpAndTurnLeft(4, 0);
	  CUP();
	  jumpAndTurnLeft(4, 0);
	  CUP();
	  jumpAndTurnLeft(4, 0);
	  CUP();
	  jumpAndTurnLeft(4, 0);
	}

Invoking fourCups() on a FontBuggle at position (3,3) facing eastward yields the following picture:

As another example of buggle jumping, consider the following testFont() method that draws the C(), d(), G(), H(), I(), P(), and U() shapes for 5x5, 4x4, 3x5, 4x4, and 4x3 rectangles for both the east and north buggle orientations:

	public void testFont() {
	  testSizes();
	  jumpAndTurnLeft(27,0);
	  testSizes();
	}
	
	public void testSizes() {
	  testLetters(5,5);
	  jump(-42,6);
	  testLetters(4,5);
	  jump(-35,6);
	  testLetters(3,5);
	  jump(-28,6);
	  testLetters(5,4);
	  jump(-42,5);
	  testLetters(5,3);
	  jump(-42,4);
	}
	
	public void testLetters(int w, int h) {
	  C(Color.red, w, h);
	  d(Color.green, w, h);
	  G(Color.black, w, h);
	  H(Color.blue, w, h);
	  I(Color.yellow, w, h);
	  P(Color.magenta, w, h);
	  U(Color.cyan, w, h);
	}

Executing testFont() should yield the following result:

---

Your Tasks

Your tasks in the problem are to define the following eight FontBuggle methods:

• The seven letter-drawing methods C(), d(), G(), H(), I(), P(), and U().
• A valentine() method that draws Fontaine's Valentine card design in a 51x51 grid, as depicted at the beginning of this problem.

You should begin the problem by downloading the HuggleWorld folder from the CS111 download folder. This folder has a file FontBuggle.java that contains skeletons of the eight methods you should define, as well as the jump(), jumpAndTurnLeft(), jumpAndTurnRight(), and jumpAndTurn180() methods described above.

The HuggleWorld folder also contains three .html for testing your methods:

• After you have defined the C(), U(), and P() methods, run the CupWorld.html applet. This should yield the fourCUPs figure depicted above.
• After you have defined all seven letter methods, run the FontTestWorld.html applet. This should yield the FontTest figure depicted above.
• After you have defined all seven letter methods and the valentine() method, run the HuggleWorld.html applet. This should yield Fontaine's Valentine card design.

Hints/Notes:

• For every FontBuggle method, you should assume that the brush state of the buggle is down when the method is called and when the method returns.
• You should define any auxiliary methods that you find helpful.
• Although you could define every letter method from scratch, it is recommended that you take advantage of the similarities between the letter shapes. For instance, a 'U' is a rotated 'C'. There are many other similarities between the letter shapes that can simplify their definitions!
• Think carefully about your arithmetic when implementing the seven letter specifications pictured above. In particular, the discrete nature of buggles makes it very easy to introduce "fencepost errors" in which the buggle's position is off by one.
  
  For instance, suppose you want a buggle to draw the 'I' shape starting in the lower left-hand corner of the rectangle facing along the width. Then even though the base of the 'I' up to and including the stem is specified to be 1 + ((width - 1)/2) cells wide, the buggle should only go forward ((width - 1)/2) steps to draw half the base of the 'I' before turning left to draw the stem of the 'I'. The reason that no "1 +" is needed is that the initial cell occupied by the buggle should not be included in the number of forward steps. This is why all the "half" distances in the letter specifications have a "1 + " at the beginning: so it will be easy for you to subtract off the 1 in your code.
• Because the trail drawn by buggle does not include the very last cell, you may find it helpful to sometimes use the public void paintCell (Color c) method, which paints the cell under the buggle with color c regardless of the buggle's color. Invoking this method does not change the color of the buggle.

One advantage of methods is that they can be used to significantly shrink the size of a program, as measured by the number of lines of Java code. For the HuggleWorld program, we challenge you to see how small you can make your FontBuggle class and still have it work correctly.

Traditionally, program size is measured by the number of lines in the program. Because this metric is very sensitive to the way you format your program (commenting, use of whitespace, placement of squiggly brackets, etc.), we will use a way of measuring the size of a Java program that is insensitive to formatting factors. In particular, we define the following two notions: