The Scenario

A magnet with only one pole is called a magnetic monopole. Whether monopoles really exist is an open problem in modem physics. Nonetheless, for this lab, we would like you to write a program that simulates the action of two monopoles. Each monopole will be represented by a simple rectangle labeled "N" for north or labeled "S" for south. Your program should allow the person using it to move either monopole around the screen by dragging it with the mouse. You know that opposite poles attract, while similar poles repel each other. So, if one monopole is dragged to a position where it is close to another monopole with the same label, the other monopole should move away as if repelled by magnetic forces. If, on the other hand, opposite poles come close to one another, the free monopole should move closer and become stuck to the monopole being dragged. The monopoles will not be allowed to rotate. They only slide up, down and across the screen.

To make things a bit more interesting one should be allowed to flip the label of a monopole by clicking on the monopole without moving the mouse. This will provide a way to separate the two monopoles if they get stuck together (since as soon as one of them is reversed it will repel the other).

You would not need a deep knowledge of magnetism and mechanics. Instead, you could exploit something every special effects expert or video game author must know. Most humans observe the world carelessly enough that even a very coarse approximation of reality will appear "realistic". Our code takes advantage of this by simplifying the behavior our monopoles. We never compute the force between two monopoles, just the distance between them. If they get too close together, our code moves them apart or makes them stick together.

Here is a demo of what we have in mind:

Design of the program

As mentioned earlier, before writing code, you should write a design. The design should show how you plan to organize your classes to accomplish the actions required. Below, we describe what methods are needed and the behavior that they should provide. To write your design, you should write (in English comments, not Java) your plan for how each method will provide the necessary behavior. You should also describe (in English) what variables you think are necessary for each class. For future labs, you'll be required to write designs like this in advance. This level of preparation will allow you to progress much more quickly in lab so that you can take better advantage of your time.

Before implementing your design, review your design: Does it make sense to you? Do you understand what instance variables are needed? When you're satisfied with it, translate it into Java code. Don't erase your comments - they'll help you keep track of what you're trying to do.

We will help you design this program by identifying the classes and methods needed. In particular, you will need two classes: the Monopole class models the behavior of a monopole and a class PoleController that is an extension of FrameWindowController.

You should start by creating a CS102/lab3 folder and create the following files with Dr. Java:

• Monopole.java defines the monopole and approximates game physics of the poles
• PoleController.java defines the interface of the games

In the following, we will focus out attention on the Monopole class

The Monopole class:

In this section, we explain how to write the Monopole class and describe the methods that needed to manipulate Monopoles. The idea is that after the Monopole class is defined, you can then write code to work with Monopoles just as you wrote code to work with FilledRects. We will see, however, that the interaction of Monopoles with the rest of your program is a little more complex than that of rectangles.

A monopole is represented by a FramedRect box and and a Text label. The box should have size 50 by 50 pixels, and the label should be center inside the box.

• Constructor

  To create a new monopole:
  

  public Monopole (double x, double y, double size, String name, DrawingCanvas canvas)

  Here x and y are coordinates of the center of the monopole, size is the size of the monopole, name is either "N" or "S".

    Example Usage

  Monopole myPole = new Monopole (xLoc, yLoc, size, "N", canvas);

• Accessor Methods

  To get information about a monopole:
  

  1. Getting the x coordinate of the pole's center:

     public double getX()

       Example Usage

     double x = somePole.getX();
     
     

  2. Getting the y coordinate of the pole's center:

     public double getY()

       Example Usage

     double y = somePole.getY();
     
     

  3. Getting the location of the pole's center:

     public Location getLocation()

       Example Usage

     Location loc = somePole.getLocation();

  4. Deciding whether a locaiton in contained in the pole:

     public boolean contains(Location point)

       Example Usage

     booleam pressed = somePole.contains(point);

• Mutator Methods

  To modify a pole:
  

  1. Moving the pole relative to its current location:

     public void move (double xoff, double yoff)

       Example Usage

     somePole.move (xOffset, yOffset);
     
     

  2. Flip a south pole to a north pole and a north pole to a south pole:

     public void flip ()

       Example Usage

     somePole.flip ();
     
     

  3. Interact with another pole, effected by either attracting or repelling:

     public void interact (Monopole anotherPole)

       Example Usage

     somePole.interact (anotherPole);
     
     

  4. Attracting another pole if close enough:

     public void attract (Monopole oppositePole)

       Example Usage

     somePole.attract (anotherPole);
     
     

  5. Repelling another pole if close enough:

     public void repel (Monopole similarPole)

       Example Usage

     somePole.repel (anotherPole);

Interaction between the poles

The monopole class has two more specialized methods: attract and repel. Each of these methods expects to be passed another Monopole as a parameter. If you say,

   currentPole.attract( anotherPole )

   currentPole.repel( anotherPole )

Each of these methods checks to see if the two Monopoles involved are close enough together to exert enough force to move anotherPole. If so, they use the move and/or moveTo methods of Monopole to either bring anotherPole next to currentPole or to move anotherPole away so that they would no longer interact.

The good news is that the repel method behaves exactly in the same way as the bump method of the balls defined in Lab 2. Look up the code for lab 2 to remind you how it is done. The attract method will be explained in class.

Adapted from materials developed at the Department of Computer Science, Williams College