Write a driver program that declares, initializes and displays an object of type Particle. Follow the approach used in class. We suggest that you set the panel size to something large, say 400x400, and the background color to black. You won't be able to run this program yet because you haven’t implemented the Particle class, but you will be forced to think about how to use the Particle class from an external perspective. You may assume that Particle objects implement a default constructor method and a display() method.

Save this driver program for use in the next exercise.

Build a Particle class with the following features:

• Instance Variables - Implement instance variables for the particle’s x-y coordinates, diameter and color. Follow the naming convention discussed in class in which instance variables start with my (e.g., myX).
• Default Constructor - Implement a default constructor method that initializes the instance variables to the following hard-coded, default values: coordinates (15, 15); diameter 25; and color white.
• Utility Method - Implement a display() method that draws the particle as a simple circle at the given x-y coordinates, with the given diameter and color.

You should now be able to run your program and see a single (stationary) particle with the default settings. When that is working, modify your class to model a moving particle by doing the following:

1. More Instance Variables - Add instance variables for the x and y components of the particle’s velocity (myVelocityX, myVelocityY). Declare them with your other instance variables and initialize them to some non-zero default values in your default constructor.
2. Mutator Method - Implement a move() method that changes the particle’s x-y coordinates according to the two velocities you implemented above according to the following algorithm:

   Increment myX by myVelocityX.
   Increment myY by myVelocityY.
   

Save this version of the program for use in the next exercise.

Add bouncing to the particle by modifying your move() method so that it receives the width and height of the output panel from its calling program and implements the following revised algorithm:

If the particle’s outer edge is beyond the left or right panel walls then
   Negate myVelocityX.
Increment myX by myVelocityX.
If the particle’s outer edge is above the panel’s ceiling or below its floor then
   Negate myVelocityY.
Increment myY by myVelocityY.

Save this version of your program for use in the next exercise.

Make the following modifications to your program:

1. Explicit-Value Constructor - Add a new explicit-value constructor that receives values for x, y, diameter, velocityX, velocityY and color from its calling program. This method verifies that these values make sense and then stores them in it instance variables. Given that any values for the coordinates, velocities or color could make sense, the only parameter that we need to check is the diameter, which should not be negative. If your constructor receives a negative diameter, have it print an error message and stop the driver (i.e., using stop()). This is a rather draconian approach, which we will improve upon later in the course. Test this by trying to construct a particle with an invalid value for the diameter. When this works, be sure to comment out the offending declaration/definition.
2. Arrays - When you have the single particle case working properly, modify the driver to create an array of particle objects each set with random x-y coordinates, diameters, x-y velocities, and colors. Where appropriate, set reasonable limits on the random values.

Save this version of the program for use in the next exercise.

Add accessor methods to your Particle class for the x coordinate, the y coordinate and the diameter. To verify that they work, add three temporary println() statements to your main draw() method that print out the x and the y coordinates and the diameter for each particle on each animation frame.

When you have this working properly, take the temporary println() statements back out and save the program.

Add collision detection to your model as follows:

1. A Utility Method - Add a hits() method to your Particle class that receives a Particle object (other) and determines if the current object has collided with other. Use the following algorithm:

   If the distance from (myX, myY) to (other.getX(), other.getY()) is less than myDiameter/2 + other.getDiameter()/2:
       Return true.
   Otherwise
       Return false.
   

2. Another Mutator Method - Add a collide() method to your Particle class that receives a Particle object (other) and reflects the particle’s velocity using the following constant definition and method:

   private final float DAMPENING_FACTOR = 0.80;
   
   // Collision algorithm based on K. Terzidis, Algorithms for Visual Design
   public void collide(Particle other) {
     float angle = atan2(other.getY() - myY, other.getX() - myX);
     float otherX = myX + cos(angle) * (myDiameter/2 + other.getDiameter()/2);
     float otherY = myY + sin(angle) * (myDiameter/2 + other.getDiameter()/2);
     float ax = (otherX - other.getX());
     float ay = (otherY - other.getY());
     myVelocityX = (myVelocityX - ax) * DAMPENING_FACTOR;
     myVelocityY = (myVelocityY - ay) * DAMPENING_FACTOR;
   }
   

3. Finally, modify the driver program’s draw() method to check all pairs of objects for collisions on each frame according to the following algorithm:

   For each particle (i)
      Move the particle.
      Display the particle.
      For each particle (j)
         If (i != j) and (particle i hits particle j) then 
            Ask particle i to handle a collision with particle j.
   

   You should have already written the first three lines of the algorithm, you must now implement the inner for loop.

Save this program.