Graphic by Keith Ohlfs

CS111, Wellesley College, Spring 2000 Problem Set 2 Due: Tuesday, September 26 at 6:00 p.m.

About this Problem Set

This problem set is intended to help you understand how Java works and to give you practice using, designing, and writing methods. Task 1 is a pencil-and-paper problem. The code for tasks 2 and 3 are available in the ps2_programs folder in the cs111 download directory on nike.

How to turn in this Problem Set

Save the modified Writing2.java and RugWorld.java files in the ps2_programs folder. Submit the entire ps2_programs folder to your drop folder on the cs111 server. Turn in a hardcopy of the JEM diagram from task 1 and your modified Writing2.java and RugWorld.java.

When submitting your hardcopies, we ask that you turn in only one package of materials. Please staple your files together with a cover page, and submit your hardcopy package by placing it in the box outside of Jennifer's office (E104, across from E101).

IMPORTANT NOTES:

1. Pay careful attention to upper and lower case letters in the filenames.
2. Once you have used Fetch to upload a file to the cs111 server, you should be sure to doublecheck that the file was actually uploaded. You can do this in Fetch by verifying that the file is now listed in your directory. Not only should you check that the file is listed, but you should check that it does not have a size of 0K. If the file isn't listed or if the size for the document is 0K, this means that there was an error in transferring it via Fetch and you must re-upload the document. When transferring a folder, you should check that its contents have been uploaded correctly. That is, you should be sure to check that every single file that you wish to submit has been uploaded correctly. Often times, although not always, you will see a message "Connection Failed" when there is an error in transferring your files.
3. If you have trouble uploading files, it may be because you have reached the limits of your Nike file system quota. You will get an error message informing you that this is the problem. In this case, you need to delete some of your old files, either from your home directory or your drop folders (which are also counted toward your quota). To delete a file in Fetch, just drag it to the Trash.
4. It is your responsibility to keep a personal back-up of every file that you submit electronically until you have received a grade for the assignment.

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 Exam 1.

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

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.
• 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 Name Writing using Methods

It is possible to use methods to expand the capabilities of the buggle name writing program from problem set 1. For example, using a larger grid, but fewer actual lines of code, a buggle can write the name "ELLIE" multiple times, around the perimeter of the grid, as shown below:

Your assignment:

Using methods, create the above grid. The file Writing2.java contains Java code which creates a larger grid and defines a LetterBuggle, a new class of objects which extends the Buggle class. A new LetterBuggle named ellie has also been created for you, along with two LetterBuggle methods; writeName, and writeE, as shown below:

// write the name "ELLIE" around the perimeter of the grid
 
public void run () {
  LetterBuggle ellie = new LetterBuggle();
  ellie.writeName();
 
  // add your code here
  // statements which will write the name around the perimeter of the grid
 
}
 
 
class LetterBuggle extends Buggle {
 
  // write the name "ELLIE", in the appropriately colored letters, by setting the color,
  // and then by invoking methods for writing the individual letters
  public void writeName () {
 
 
    this.setColor(Color.red);
    this.writeE();    // write the first "E", in red
 
    // add your code here
    // statements which will write the "L L I" in the correct colors
 
    this.setColor(Color.green);
    this.writeE();    // write the last "E", in green
 
  }
 
 
  //write the letter "E"
  public void writeE() {
    this.brushDown();
    this.forward(2);
 
    // add your code here
    // the rest of the statements for writing an "E"
 
  }
 
 
  // add your code here
  // methods for writing the other letters in the name
 
}
 

Perform the following steps to solve the problem:

• Add the rest of the code to the writeE method so that it draws the letter "E". This code should be very similar to the code you used in task 1 for that purpose! Assume that when you start to write a letter, the buggle is in the lower left square of a 3x5 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 3x5 grid, separated by one space from the previous letter, facing the direction of writing).
• Define similar methods to write an "L" and an "I".
• Add code to the writeName method so that it draws the name "ELLIE" by setting the color and then invoking the methods which write the individual letters.
• Add code to the run method so that it draws the name 4 times around the perimeter of the grid, by invoking the writeName method repeatedly. You will need to come up with a way to turn and change your heading at each corner of the grid.

You must conform to the following rules:

1. You may not invoke the "setPosition" or "setHeading" methods.
2. You should use the methods "brushUp" and "brushDown" where appropriate.
3. Each letter should fit in a 3x5 grid, and should be separated from the next letter by one blank space.
4. Ellie must draw the letters in the appropriate colors (use "setColor" to change colors).
5. Ellie must end up in the position shown above, facing the correct direction (EAST).
6. Use methods to solve the problem.

Task 3: The Buggle Bagel Ruggle Company

The buggles from Problem Set 1, becky, bobby, bertie, billy and benny, had the foresight to copyright their Buggle Olympic Symbol. As a result, they made a killing on the use of the logo for Buggle Olympics memorabilia and merchandise. So, they decided to invest in a rug-making enterprise: The Buggle Bagel Ruggle Company, which designs and weaves rugs made by dropping bagels in interesting ways on a BuggleWorld grid.

Here is an example of a rug they created:

The buggles are great designers, but, unfortunately, they don't know much about manufacturing. It takes so long to hand-drop the bagels individually that it's impossible to make any money. Luckily for them, there is a way to automate the production of the rugs. As it turns out, the design shown above can be produced using just 4 different 3x3 grids of bagel patterns:

pattern 1

pattern 2

pattern 3

pattern 4

The rug itself is created by placing these patterns side by side to tile the entire rug. The rug, divided into 3x3 grids (outlined in black lines), is shown below:

The rug pattern includes a lot of repetitive patterns. This means that there are many opportunities for using methods to generate the pattern efficiently. Your task is to write the code which will create the rug pattern shown above in the most efficient manner you can think of. The code for this problem is contained in the RugWorld folder. The file RugWorld.java contains the initial set-up for creating the rug shown above. becky, bobby, bertie, benny and billy have hired a RugBuggle (another new class of objects which extends the Buggle class) named weaver to produce the rugs. You should add your code to this file, but you should not remove any existing code.

You must observe the following constraints:

• You can not modify any of the code in the run method.
• You should use a single RugBuggle for the entire rug (weaver, who has already been created in the file).
• You may not, and do not need to, use the setPosition() or setHeading() methods. You can use any of the other Buggle methods.
• You should draw the colors and bagels exactly as shown in the rug.
• The buggle must finish in the same place it started, facing the same direction (i.e. EAST).
• You must create the rug pattern by using the 4 3x3 patterns shown above.
• The buggle must start in the bottom left corner of each pattern (as shown above) facing EAST. The buggle must finish in position to start the next pattern element as shown below:
  

• You must name the method that generates each of the four patterns above as pattern1, pattern2, pattern3, and pattern4, respectively. Each pattern should take two Color parameters. The first color is the color represented in black, and the second color is the color represented in yellow in the above pictures. Name your parameters c1 and c2. For example, the skeleton for the pattern1 method should look like this:
  

  public void pattern1 (Color c1, Color c2) {
    // add code here
  }
   

• You must also define the following methods:
  
  • makeRug: this method creates the entire rug; it has no parameters.

     

  • outerRing: this method draws the outer ring; it has no parameters. It should have two Color variables. Name your variables c1 and c2. c1 represents the outer color of the border (blue in this rug) and c2 represents the inner color of the border (red in this rug). A snapshot of the outerRing is shown below:
    

     

  • innerPattern: this method draws the inner pattern which is repeated twice in the rug as shown below:
    

    This method should take two Color parameters named c1 and c2. c1 will represent the areas colored in black above and c2 will represent the areas colored in yellow above. Note that the actual rug uses the colors cyan and pink in one instantiation of the pattern and green and orange in the other instantiation of the pattern.

     

  • innerRing: this method draws the border of the inner pattern. This method should also have two Color parameters. Follow the naming conventions as given for the other methods.
    

     

  • innerRow: this method draws the pattern in the center of the innerPattern. This method should have two Color parameters.
    

     

  • centerRow: this method draws the pattern in the center of the rug. This method should also have two Color parameters.

  The six methods above must meet the invariant that the buggle must start and finish in the same cell, facing the same direction. You must assume that the buggle starts in the bottom left corner of each pattern (as shown above) facing EAST and should finish that way.

Helpful Hints:

• The paintCell(Color c) method can be used to paint the cell under the buggle a certain color without having to move the buggle. For example,
  sara.paintCell(Color.gray);
  will paint the cell under sara gray. sara's brush state is not changed by the invocation of the paintCell method.
• The RugBuggle's brush is initially up before making the rug.
• You can temporarily modify the run method to test out small parts of your code. Comment out the invocation of makeRug and add what you want to test. Remember that you can comment out a line of code by adding // (two slashes) before that line of code.
• The row patterns are created by alternating patterns 3 and 4 like so (pattern3--pattern4--pattern3):
  
• You should feel free to add as many more methods as you see fit. There are many more opportunities for creating methods in this problem.