Our first iteration requires updates to both the simulation engine and to the model of the particle. Proceed as follows:

• In the Particle class:
  1. Add an instance method called render that receives a canvas (in addition to self) and uses the canvas and instance variables to draw a circular representation of the particle. You can use:

     canvas.create_oval(self._x - self._radius,
                             self._y - self._radius,
                             self._x + self._radius,
                             self._y + self._radius,
                             fill = self._color)
     				

• In the ParticleSimulation class:
  1. Add an instance variable self.p1 which is an instance of the Particle class. This particle should be a default particle.
  2. Ask the particle to render itself on the canvas. You can use self.p1.render(self.canvas) for this step.

Verify that a single particle appears on the canvas before proceeding.

To make a particle appear to move around the screen, we need to set up an animation loop, as well as allow the particle to change its location (according to its velocities). Proceed as follows:

• In the Particle class:
  1. Add an instance method called move that receives a canvas (in addition to self).
  2. The move method should update the x and y coordinates of the particle according to their velocities (e.g. self._x += self._velX).
  3. The move method should cause the particle to bounce at the edge of the screen (e.g., if (self._x + self._radius > canvas.winfo_reqwidth() and self._velX > 0) or (self._x - self._radius < 0 and self._velX < 0) then negate the x velocity). Be sure to deal with both the walls and the floor/ceiling.
• In the ParticleSimulation class:
  1. Create a method render(), that implements the following algorithm.
     1. If the program is not yet terminated:
        1. Clear the canvas using self.canvas.delete(ALL)
        2. Tell the particle p1 to move
        3. Tell the particle p1 to render itself
        4. Reschedule this method to be called after a brief period: self.canvas.after(50, self.render)
  2. Replace the call in the constructor that tells the particle to render itself with a call to self.render()

By the end of this step, a single particle should bounce around the screen.

We could write our program to use a fixed number of particles, but to maximize our fun, let's create a button that will let the user add random particles to the screen. Note: We will not need to update our Particle class at all, because we already have a working model of a particle. We only need to update our simulation driver. Proceed as follows:

• Within the __init__ method:
  1. Replace the declaration of self.p1 with the creation of an empty list called self.p_list
  2. Add a Button below the canvas with the text 'Add particle', and associate clicking the button with a method called self.add_particle
• Add the instance method add_particle:
  1. Create a particle with a random x, y, velx, vely and color (x and y should be on the screen, velx and vely should be between -25 and 25)
  2. Append the particle to self.p_list
• Update the algorithm implemented in render() as follows:
  1. If the program is not yet terminated:
     1. Clear the canvas using self.canvas.delete(ALL).
     2. For each particle in self.p_list
        1. Tell the current particle to move itself.
        2. Tell the current particle to render itself.
     3. Reschedule this method to be called after a brief period: self.canvas.after(50, self.render)

Verify that each time you click the add particle button, a new, random particle is added to the screen.

To remove a particle from our animation, we'll need the ability to determine how close a mouse click is from a particle. Since a particle keeps track of its own location, we'll need accessors to retrieve this information so we can compute the distance between a mouse event and a particle in our simulation. Proceed as follows:

• In the Particle class:
  1. Add an accessor for the x coordinate of a particle
  2. Add an accessor for the y coordinate of a particle
  3. Add an accessor for the radius of a particle
• In the ParticleSimulation class:
  • Within the __init__ method:
    1. Bind a click of the first button to a method called check_remove_particle. You can use this code:

       self.canvas.bind('<Button-1>', self.check_remove_particle)

  • Create a new method called check_remove_particle that implements the following algorithm.
    1. Receive an event in addition to self.
    2. For each particle in a copy of self.p_list:
       1. If the distance from the mouse event to center of the particle is less than radius, remove the particle from the original list

    Note that you can

    • use event.x and event.y to get the location of the mouse event.
    • use your accessors to get the x, y and radius of the current particle.
    • create a copy of a list using a slice of the original (e.g. copy = self.p_list[:] )

You'll notice that you have to click very carefully to remove a particle (it will be much easier on more slowly moving particles). This is due to the interaction between the animation loop and the event loop. As long as you can get some particle to disappear, you're good to go on.

Add the following code to your Particle class: collision code. The constant should be added above the definition of the class, and then the two methods should be added to the Particle class. This code implements collision detection and bouncing behavior; read through the documentation to get an idea of how it works.

Now, update the algorithm for the animation loop in your constructor as follows.

1. While the program is not yet terminated:
   1. Clear the canvas using self.canvas.delete(ALL).
   2. For each particle p1 in self.p_list
      1. Move the particle.
      2. Render the particle.
      3. For each element p2 of self.p_list:
         1. Ask the current particle to bounce itself off of p2 (using p1.bounce(p2)).
   3. Pause the animation briefly using self.canvas.after(50).
   4. Tell the canvas to update using self.canvas.update().

   This new step 1.c bounces the current ball off of each of the other balls. If there is no overlap, the call to bounce() does nothing.