July 23, 2014
Hot Topics:
RSS RSS feed Download our iPhone app

Fun with Java: Sprite Animation, Part 4

  • October 18, 2001
  • By Richard G. Baldwin
  • Send Email »
  • More Articles »

Java Programming, Lecture Notes #1456


Preface

This is one of the lessons in a miniseries that concentrates on having fun while programming in Java.

This miniseries will include a variety of Java programming topics that fall in the category of fun programming.  This particular lesson is the fourth in of a group of lessons that will teach you how to write animation programs in Java.  The first lesson in the group was entitled Fun with Java: Sprite Animation, Part 1.  The previous lesson was entitled Fun with Java: Sprite Animation, Part 3.

Viewing tip

You may find it useful to open another copy of this lesson in a separate browser window.  That will make it easier for you to scroll back and forth among the different figures and listings while you are reading about them.

Supplementary material

I recommend that you also study the other lessons in my extensive collection of online Java tutorials.  You will find those lessons published at Gamelan.com.  However, as of the date of this writing, Gamelan doesn't maintain a consolidated index of my Java tutorial lessons, and sometimes they are difficult to locate there.  You will find a consolidated index at Baldwin's Java Programming Tutorials.

Preview

This is one of a group of lessons that will teach you how to write animation programs in Java.  These lessons will teach you how to write sprite animation, frame animation, and a combination of the two.

Spherical sea creatures

The first program, being discussed in this lesson, will show you how to use sprite animation to cause a group of colored spherical sea creatures to swim around in a fish tank.  A screen shot of the output produced by this program is shown in Figure 1.

Figure 1.  Animated spherical sea creatures in a fish tank.

Changing color with frame animation

Many sea creatures have the ability to change their color in very impressive ways.  The second program that I will discuss in subsequent lessons will simulate that process using a combination of sprite and frame animation.

Animated sea worms

The third program, also to be discussed in a subsequent lesson, will use a combination of sprite animation, frame animation, and some other techniques to cause a group of multi-colored sea worms to slither around in the fish tank.  In addition to slithering, the sea worms will also change the color of different parts of their body, much like real sea creatures.

A screen shot of the output from the third program is shown in Figure 2.

Figure 2.  Animated sea worms in a fish tank.

Getting the GIF files

Figure 3 shows the GIF image files that you will need to run these three programs.
 

               

Figure 3.  GIF image files that you will need.

You should be able to capture the images by right-clicking on them individually, and then saving them into files on your local disk.  Having done that, you will need to rename the files to match the names that are hard-coded into the programs.

Review of previous lesson

In the previous lesson, I discussed the unusual nature of the getter methods for the width and height properties of an Image object.

I introduced and briefly discussed the concept of an ImageObserver object in conjunction with the getWidth and getHeight methods of an Image object.

I showed you how to set the size of the Frame to be the same as the size of the background image.

I discussed the use of an object of the controlling class as an animation thread.

Also, in the previous lesson, I completed my discussion of the constructor for the controlling class.

What's in this lesson?

In this lesson, I will explain the behavior of the run method of the animation thread as well as the makeSprite method of the controlling class.

I will provide a preview of the SpriteManager class, which will be discussed in detail in a subsequent lesson.  I will also provide a brief preview of the Sprite class, which will be discussed in detail in a subsequent lesson.

I will discuss the repaint, update, and paint methods of the Component class.  I will also discuss the timer loop used in this program, and suggest an alternative approach that makes use of a Timer object to fire Action events.

Finally, I will summarize everything that we have learned so far in this and the previous three lessons.

Discussion and Sample Program

This program is so long that several lessons will be required to discuss it fully.  Rather than to make you wait until I complete all of those lessons to get your hands on the program, I have provided a copy of the entire program in Listing 6 near the end of the lesson.  That way, you can copy it into a source file on your local disk, compile it, run it, and start seeing the results.

Discuss in fragments

As usual, I will discuss the program in fragments.  In the previous lesson, I completed my discussion of the constructor for the controlling class and promised to explain the run method of the controlling class in this lesson.

The run method

The run method sets up the animation scenario and then goes into an infinite loop, updating the animation process approximately twelve times per second.

The code in Listing 1 shows the beginning of the run method and the instantiation of a new object of the class SpriteManager.
 

  public void run() {
    spriteManager = new SpriteManager(
             new BackgroundImage(
               this, backGroundImage));

Listing 1

The SpriteManager class

As the name implies, an object of the SpriteManager class can be used to manage a collection of sprites.  This class will be discussed in detail later.  For the time being, here are some of the attributes of the SpriteManager class.

SpriteManager constructor

The constructor for the SpriteManager class requires an incoming parameter of type BackgroundImage. The BackgroundImage class is a convenience class designed to facilitate certain operations involving the background image displayed on the Frame.

A collection of sprites in a Vector object

An object of the SpriteManager class stores references to a collection of sprites in an object of type Vector.  A public method named addSprite can be invoked to cause a new sprite to be added to the collection.

Finding a parking place for a sprite

One of the public methods of the SpriteManager class is a method named getEmptyPosition.  This method attempts to identify a location within the Frame that does not currently contain a sprite.  This makes it possible to create a population of sprites without having them initially occupying the same physical space.

Updating the sprite positions

Another public method of the SpriteManager class is a method named upDate (not to be confused with the update method of the Component class).  When this method is invoked, the SpriteManager object causes all of the sprites in its collection to change their position according to values stored in a motion vector owned by each sprite.

When the sprites change their positions, collisions can and do occur.  Such collisions are handled by the SpriteManager using private methods named testForCollision and bounceOffSprite.

Drawing the scene

Another public method of the SpriteManager class is named drawScene.  When this method is invoked, a new background image is drawn on the Frame.  This has the effect of erasing all of the sprites from the scene.  The method then causes each of the sprites to be drawn in their respective positions.

Creating the collection of sprites

The code in Listing 2 shows the beginning of a for loop that creates fifteen individual sprites and stores references to those sprites in the collection managed by the SpriteManager object.

Six Image objects were created earlier and stored in an array of type Image[] by the constructor.  These Image objects are used to provide the visual manifestations of the sprites.  (Unfortunately, this code may be a little difficult to follow due to the squeezing required by this narrow publication format.)
 

    for (int cnt = 0; cnt < 15; cnt++){
      Point position = spriteManager.
        getEmptyPosition(new Dimension(
           gifImages[0].getWidth(this),
           gifImages[0].
                     getHeight(this)));

Listing 2

Getting the size of a sprite

The code in Listing 2 assumes that all of the images used to create sprites are the same size, (which they are in this program).  In order to get a representative size for a sprite, this code applies the getWidth and getHeight methods to the Image object referred to by the reference stored in element 0 of the array of Image objects.

Finding an empty parking place for a sprite

The resulting width and height values are used to populate a Dimension object, which is passed to the getEmptyPosition method of the SpriteManager object.  As explained earlier, this method locates a position not currently occupied by a sprite and returns the coordinates of that position as a reference to an object of type Point.

The makeSprite method

The controlling class also contains a method named makeSprite, which I will discuss in more detail later.  For the time being, suffice it to say that this method is used to create and return an object of the Sprite class.  (I also haven't discussed the Sprite class yet, but will discuss it in a subsequent lesson.)

Among other things, the constructor for the Sprite class requires a reference to an Image object and a reference to a Point object.  The new Sprite object represents itself visually using the Image.  The initial position of the new Sprite object is determined by the contents of a Point object.

Creating a new Sprite object

The code in Listing 3 (still inside the for loop) passes the Point object obtained from the getEmptyPosition method above, along with an integer value between 0 and 6 to the makeSprite method.  The makeSprite method uses that integer to identify an element in the array of Images, and passes the Point and the Image to the constructor for the Sprite class (along with some other required information).

The makeSprite method returns a reference to a new Sprite object, which is added to the collection of Sprite objects being managed by the SpriteManager object.
 

      spriteManager.addSprite(
        makeSprite(position, cnt % 6));
    }//end for loop

Listing 3

The SpriteManager is populated

The result of the for loop that ends in Listing 3 is a collection of 15 sprites being managed by the SpriteManager object.  Because some of the sprites share the same Image objects for their visual manifestation, some of the spherical sea creatures in Figure 1 look the same.

Which way should I go?

In addition to an initial position and Image, each of the Sprite objects contains a two-dimensional motion vector, which indicates the direction and speed used by the sprite when it changes its location.

The components of the initial motion vector for each sprite are created using a random number generator by the makeSprite method.  As we will see when we examine the Sprite class in detail, the motion vector for each sprite can be modified later, also based on a random number generator.

It's time to party

At this point, the stage is set.  The background is in place.  Each of the fifteen sprites has been positioned and has been given a motion vector.  The time has come to start the animation process running.

The animation loop

The code in Listing 4 was taken from the book entitled Teach Yourself Internet Game Programming with Java in 21 Days, by Michael Morrison.

(For those systems where animation timing is really critical, a newer, and possibly better approach uses a Timer object that can be set to fire an Action event at predetermined intervals.  This approach is described in The JFC Swing Tutorial, A Guide to Constructing GUIs, by Walrath and Campione.)

Update the display

The code in Listing 4 attempts to cause the display to update itself once each 83 milliseconds, or about twelve times per second.
 

    long time = 
            System.currentTimeMillis();
    while (true) {//infinite loop
      spriteManager.update();
      repaint();
      try {
        time += animationDelay;
        Thread.sleep(Math.max(0,time - 
          System.currentTimeMillis()));
      }catch (InterruptedException e) {

        System.out.println(e);
      }//end catch
    }//end while loop
  }//end run method

Listing 4

Update, repaint, and sleep

The code in Listing 4 enters an infinite loop where it invokes the update method on the SpriteManager object to cause all the sprites to change their position.  This causes sprites to move, causes collisions between sprites to occur, causes collisions to be handled, causes sprites to bounce off the walls, etc.

Then the code in Listing 4 invokes the repaint method on the Frame object.  This sends a message to the operating system asking that the Frame object and all its contents be redrawn as soon as possible.

Tell me more about the repaint method

The repaint method of the Frame class is inherited from the Component class.  Here is what Sun has to say about the repaint method of the Component class:

"This method causes a call to this component's update method as soon as possible."
Now, tell me more about the update method

At this point, we need to take a look at the update method of the Component class.  (Don't confuse this method named update with the update method of the SpriteManager class.  I now realize that it would have been less confusing if I had named the method in the SpriteManager class something other than update.)

Here is part of what Sun has to say about the update method of the Component class:

"The update method of Component does the following:
    • Clears this component by filling it with the background color.
    • Sets the color of the graphics context to be the foreground color of this component.
    • Calls this component's paint method to completely redraw this component."
Is this the behavior that we want?

The above quotation from Sun describes the default behavior of the update method.  Normally for non-animated programs, we would be happy with that default behavior and wouldn't override the update method.  We would simply leave it alone and override the paint method to cause the overridden paint method to produce the output that we want to see on the screen.

Overriding the update method of the Component class

However, filling the component with the background color during every repaint can sometimes cause an undesirable flashing effect.  As a result, animation programmers often override the update method to give it different behavior, and that is what I will do.  I will discuss the behavior of my overridden update and paint methods in the next lesson.

Time for a little nap

Following the call to repaint, the thread goes to sleep for a period of time (other activities could be taking place on other threads during this sleep period).  The length of the sleep period is calculated such that the sleep period plus the processing time is approximately equal to 83 milliseconds (twelve repaints per second).

How accurate is the repaint rate?

Just how well this approach succeeds in achieving a uniform repaint rate of twelve repaints per second will depend on the accuracy of the time returned by the method named currentTimeMillis(This is the area where the use of a Timer object may be more reliable than the homebrew timer approach used in this program.)

Time to wake up

The thread wakes up at the end of the specified sleep period.  Each time the thread wakes up, it invokes another update on the SpriteManager object to cause the sprites to change their positions, requests another repaint, and goes back to sleep.

This process continues until the user terminates the program by clicking the close button on the Frame.

The end of the run method

That completes the discussion of the run method of the controlling class.

Before closing out this lesson, I'm going to explain the behavior of the makeSprite method that I used earlier to populate the SpriteManager object.

The makeSprite method

The makeSprite method is a short and very simple method.  The entire method is shown in Listing 5.
 

  private Sprite makeSprite(
       Point position, int imageIndex){
    return new Sprite(
          this, 
          gifImages[imageIndex], 
          position, 
          new Point(rand.nextInt() % 5,
                  rand.nextInt() % 5));
  }//end makeSprite()

Listing 5

A new Sprite object, please

This method instantiates and returns a new object of the Sprite class (I will provide a detailed discussion of the Sprite class in a subsequent lesson).

The constructor for the Sprite class requires four parameters:

  • A reference to an ImageObserver object (this) that can be used later in calls to the drawImage method of the Graphics class.
  • A reference to an Image object that can be used as the visual manifestation of the sprite.
  • The initial position for the sprite.
  • A reference to a Point object containing the horizontal and vertical components for the initial motion vector for the sprite.
The motion vector

Of these four parameters, only the motion vector is relatively new to us at this point (the initial motion vector determines the initial direction and speed of motion for the sprite.).

The makeSprite method uses a random number generator to get the values for the components of the motion vector.  The modulus operator (%) is used to guarantee that each of the component values is an integer value between -5 and +5.

An aside to this discussion

In a subsequent lesson, you will see that I am able to make major changes to the animation behavior of the program by making a very simple modification to the makeSprite method and by making changes to the definition of the Sprite class.  Otherwise, all of the code that I have discussed so far will remain unchanged when I make those behavioral changes to the program.

Summary

In this lesson, I explained the behavior of the run method of the animation thread as well as the makeSprite method of the controlling class.

I provided a preview of the SpriteManager class, which will be discussed in detail in a subsequent lesson.  I also provided a brief preview of the Sprite class, which will be discussed in detail in a subsequent lesson.

I discussed the repaint, update, and paint methods of the Component class.  I also discussed the timer loop used in this program, and suggested an alternative approach that makes use of a Timer object to fire Action events.

Let's recap

This would probably be a good place to recap what we have learned so far.  The controlling class extends the Frame class and implements the Runnable interface.  Thus, an object of the controlling class is used to provide the visual manifestation of the program as a visual Frame object.  An object of the controlling class is also suitable for using as an animation thread, which controls the overall behavior of the animation process.  In other words, an object of the controlling class acts both as the director of the play, and the stage upon which the play is performed.

The constructor for the controlling class

The main method of the controlling class instantiates an object of the controlling class, thus causing the constructor for the controlling class to be executed.

The constructor for the controlling class causes seven Image objects to be created.  Each Image object is based on the pixel contents of a GIF file.

The Image objects

One of the Image objects is used to produce the background scenery against which the animation is played out.  The other six Image objects are used to provide the visual manifestation of the sprites.  Each Image object provides the visual manifestation for more than one sprite.  Therefore, some of the sprites look alike (twins in some cases and triplets in others).

After the Image objects have been created, the size of the Image object used for the background scenery is used by the constructor to set the size of the Frame.  Then the Frame is made visible.

The animation thread

Finally, the constructor creates the animation thread and starts it running.  From this point forward, the run method of the controlling class controls the animation behavior of the program.

The run method

The run method begins by creating and populating a SpriteManager object.  An object of the SpriteManager class is capable of managing a collection of sprites, causing them to update their positions on demand, and dealing with collisions between the sprites.

The SpriteManager object

The SpriteManager object is populated with fifteen separate Sprite objects.  Each sprite object has a visual manifestation based on one of the six Image objects.  Each sprite object also has an initial position based on a random number and a motion vector whose components are also based on random numbers.  The motion vector is used to determine the next position of the sprite when the sprite is told by the SpriteManager to change its position.

The animation loop

Then the run method enters an infinite loop, iterating approximately twelve times per second.  At the beginning of each iteration, the SpriteManager is told to update the positions of all of the sprites in its collection.  It does so, dealing with collisions in the process.

A repaint request

Once during each iteration, the run method sends a message to the operating system asking it to repaint the Frame object on the screen.  That brings us to the point where we are right now.

Honoring the repaint request

When the operating system honors the request to repaint, it invokes the upDate method on the Frame object, (which normally does some initialization and then invokes the paint method).  The update method is overridden in this program to cause the new scene to be drawn in its entirety, showing each of the sprites in its new position superimposed upon the background image.  (Note that in this case, the update method does not invoke the paint method, because there is nothing for the paint method to do.)

An offscreen graphics context

When drawing the scene, the update method first draws the scene on an offscreen graphics context, and then causes the scene to be transferred from that context to the screen context.  This is done to improve the animation quality of the program.

What's Next?

There are only two methods remaining to be discussed in the controlling class:  update and paint.  The next lesson will explain the behavior of the overridden update and paint methods.  As explained above, the update method is invoked by the operating system in response to a repaint request on the Frame.

Complete Program Listing

A complete listing of the program is provided in Listing 6.
 
/*File Animate01.java
Copyright 2001, R.G.Baldwin

This program displays several animated
colored spherical creatures swimming 
around in an aquarium.  Each creature 
maintains generally the same course
with until it collides with another 
creature or with a wall.  However, 
each creature has the ability to 
occasionally make random changes in 
its course.

**************************************/
import java.awt.*;
import java.awt.event.*;
import java.util.*;

public class Animate01 extends Frame 
                  implements Runnable {
  private Image offScreenImage;
  private Image backGroundImage;
  private Image[] gifImages = 
                          new Image[6];
  //offscreen graphics context
  private Graphics 
                  offScreenGraphicsCtx;
  private Thread animationThread;
  private MediaTracker mediaTracker;
  private SpriteManager spriteManager;
  //Animation display rate, 12fps
  private int animationDelay = 83;
  private Random rand = 
                new Random(System.
                  currentTimeMillis());
  
  public static void main(
                        String[] args){
    new Animate01();
  }//end main
  //---------------------------------//

  Animate01() {//constructor
    // Load and track the images
    mediaTracker = 
                new MediaTracker(this);
    //Get and track the background 
    // image
    backGroundImage = 
        Toolkit.getDefaultToolkit().
          getImage("background02.gif");
    mediaTracker.addImage(
                   backGroundImage, 0);
    
    //Get and track 6 images to use 
    // for sprites
    gifImages[0] = 
           Toolkit.getDefaultToolkit().
               getImage("redball.gif");
    mediaTracker.addImage(
                      gifImages[0], 0);
    gifImages[1] = 
           Toolkit.getDefaultToolkit().
             getImage("greenball.gif");
    mediaTracker.addImage(
                      gifImages[1], 0);
    gifImages[2] = 
           Toolkit.getDefaultToolkit().
              getImage("blueball.gif");
    mediaTracker.addImage(
                      gifImages[2], 0);
    gifImages[3] = 
           Toolkit.getDefaultToolkit().
            getImage("yellowball.gif");
    mediaTracker.addImage(
                      gifImages[3], 0);
    gifImages[4] = 
           Toolkit.getDefaultToolkit().
            getImage("purpleball.gif");
    mediaTracker.addImage(
                      gifImages[4], 0);
    gifImages[5] = 
           Toolkit.getDefaultToolkit().
            getImage("orangeball.gif");
    mediaTracker.addImage(
                      gifImages[5], 0);
    
    //Block and wait for all images to 
    // be loaded
    try {
      mediaTracker.waitForID(0);
    }catch (InterruptedException e) {
      System.out.println(e);
    }//end catch
    
    //Base the Frame size on the size 
    // of the background image.
    //These getter methods return -1 if
    // the size is not yet known.
    //Insets will be used later to 
    // limit the graphics area to the 
    // client area of the Frame.
    int width = 
        backGroundImage.getWidth(this);
    int height = 
       backGroundImage.getHeight(this);

    //While not likely, it may be 
    // possible that the size isn't
    // known yet.  Do the following 
    // just in case.
    //Wait until size is known
    while(width == -1 || height == -1){
      System.out.println(
                  "Waiting for image");
      width = backGroundImage.
                        getWidth(this);
      height = backGroundImage.
                       getHeight(this);
    }//end while loop
    
    //Display the frame
    setSize(width,height);
    setVisible(true);
    setTitle(
        "Copyright 2001, R.G.Baldwin");

    //Create and start animation thread
    animationThread = new Thread(this);
    animationThread.start();
  
    //Anonymous inner class window 
    // listener to terminate the 
    // program.
    this.addWindowListener(
                   new WindowAdapter(){
      public void windowClosing(
                        WindowEvent e){
        System.exit(0);}});
    
  }//end constructor
  //---------------------------------//

  public void run() {
    //Create and add sprites to the 
    // sprite manager
    spriteManager = new SpriteManager(
             new BackgroundImage(
               this, backGroundImage));
    //Create 15 sprites from 6 gif 
    // files.
    for (int cnt = 0; cnt < 15; cnt++){
      Point position = spriteManager.
        getEmptyPosition(new Dimension(
           gifImages[0].getWidth(this),
           gifImages[0].
                     getHeight(this)));
      spriteManager.addSprite(
        makeSprite(position, cnt % 6));
    }//end for loop

    //Loop, sleep, and update sprite 
    // positions once each 83 
    // milliseconds
    long time = 
            System.currentTimeMillis();
    while (true) {//infinite loop
      spriteManager.update();
      repaint();
      try {
        time += animationDelay;
        Thread.sleep(Math.max(0,time - 
          System.currentTimeMillis()));
      }catch (InterruptedException e) {
        System.out.println(e);
      }//end catch
    }//end while loop
  }//end run method
  //---------------------------------//
  
  private Sprite makeSprite(
      Point position, int imageIndex) {
    return new Sprite(
          this, 
          gifImages[imageIndex], 
          position, 
          new Point(rand.nextInt() % 5,
                  rand.nextInt() % 5));
  }//end makeSprite()
  //---------------------------------//

  //Overridden graphics update method 
  // on the Frame
  public void update(Graphics g) {
    //Create the offscreen graphics 
    // context
    if (offScreenGraphicsCtx == null) {
      offScreenImage = 
         createImage(getSize().width, 
                     getSize().height);
      offScreenGraphicsCtx = 
          offScreenImage.getGraphics();
    }//end if
    
    // Draw the sprites offscreen
    spriteManager.drawScene(
                 offScreenGraphicsCtx);

    // Draw the scene onto the screen
    if(offScreenImage != null){
         g.drawImage(
           offScreenImage, 0, 0, this);
    }//end if
  }//end overridden update method
  //---------------------------------//

  //Overridden paint method on the 
  // Frame
  public void paint(Graphics g) {
    //Nothing required here.  All 
    // drawing is done in the update 
    // method above.
  }//end overridden paint method
    
}//end class Animate01
//===================================//

class BackgroundImage{
  private Image image;
  private Component component;
  private Dimension size;

  public BackgroundImage(
                  Component component, 
                  Image image) {
    this.component = component;
    size = component.getSize();
    this.image = image;
  }//end construtor
  
  public Dimension getSize(){
    return size;
  }//end getSize()

  public Image getImage(){
    return image;
  }//end getImage()

  public void setImage(Image image){
    this.image = image;
  }//end setImage()

  public void drawBackgroundImage(
                          Graphics g) {
    g.drawImage(
               image, 0, 0, component);
  }//end drawBackgroundImage()
}//end class BackgroundImage
//===========================

class SpriteManager extends Vector {
  private BackgroundImage 
                       backgroundImage;

  public SpriteManager(
     BackgroundImage backgroundImage) {
    this.backgroundImage = 
                       backgroundImage;
  }//end constructor
  //---------------------------------//
  
  public Point getEmptyPosition(
                 Dimension spriteSize){
    Rectangle trialSpaceOccupied = 
      new Rectangle(0, 0, 
                    spriteSize.width, 
                    spriteSize.height);
    Random rand = 
         new Random(
           System.currentTimeMillis());
    boolean empty = false;
    int numTries = 0;

    // Search for an empty position
    while (!empty && numTries++ < 100){
      // Get a trial position
      trialSpaceOccupied.x = 
        Math.abs(rand.nextInt() %
                      backgroundImage.
                      getSize().width);
      trialSpaceOccupied.y = 
        Math.abs(rand.nextInt() %
                     backgroundImage.
                     getSize().height);

      // Iterate through existing 
      // sprites, checking if position 
      // is empty
      boolean collision = false;
      for(int cnt = 0;cnt < size();
                                cnt++){
        Rectangle testSpaceOccupied = 
              ((Sprite)elementAt(cnt)).
                    getSpaceOccupied();
        if (trialSpaceOccupied.
                 intersects(
                   testSpaceOccupied)){
          collision = true;
        }//end if
      }//end for loop
      empty = !collision;
    }//end while loop
    return new Point(
                 trialSpaceOccupied.x, 
                 trialSpaceOccupied.y);
  }//end getEmptyPosition()
  //---------------------------------//
  
  public void update() {
    Sprite sprite;
    
    //Iterate through sprite list
    for (int cnt = 0;cnt < size();
                                cnt++){
      sprite = (Sprite)elementAt(cnt);
      //Update a sprite's position
      sprite.updatePosition();

      //Test for collision. Positive 
      // result indicates a collision
      int hitIndex = 
              testForCollision(sprite);
      if (hitIndex >= 0){
        //a collision has occurred
        bounceOffSprite(cnt,hitIndex);
      }//end if
    }//end for loop
  }//end update
  //---------------------------------//
  
  private int testForCollision(
                   Sprite testSprite) {
    //Check for collision with other 
    // sprites
    Sprite  sprite;
    for (int cnt = 0;cnt < size();
                                cnt++){
      sprite = (Sprite)elementAt(cnt);
      if (sprite == testSprite)
        //don't check self
        continue;
      //Invoke testCollision method 
      // of Sprite class to perform
      // the actual test.
      if (testSprite.testCollision(
                               sprite))
        //Return index of colliding 
        // sprite
        return cnt;
    }//end for loop
    return -1;//No collision detected
  }//end testForCollision()
  //---------------------------------//
  
  private void bounceOffSprite(
                    int oneHitIndex,
                    int otherHitIndex){
    //Swap motion vectors for 
    // bounce algorithm
    Sprite oneSprite = 
        (Sprite)elementAt(oneHitIndex);
    Sprite otherSprite = 
      (Sprite)elementAt(otherHitIndex);
    Point swap = 
           oneSprite.getMotionVector();
    oneSprite.setMotionVector(
        otherSprite.getMotionVector());
    otherSprite.setMotionVector(swap);
  }//end bounceOffSprite()
  //---------------------------------//
  
  public void drawScene(Graphics g){
    //Draw the background and erase 
    // sprites from graphics area
    //Disable the following statement 
    // for an interesting effect.
    backgroundImage.
                drawBackgroundImage(g);

    //Iterate through sprites, drawing
    // each sprite
    for (int cnt = 0;cnt < size();
                                 cnt++)
      ((Sprite)elementAt(cnt)).
                    drawSpriteImage(g);
  }//end drawScene()
  //---------------------------------//
  
  public void addSprite(Sprite sprite){
    add(sprite);
  }//end addSprite()
  
}//end class SpriteManager
//===================================//

class Sprite {
  private Component component;
  private Image image;
  private Rectangle spaceOccupied;
  private Point motionVector;
  private Rectangle bounds;
  private Random rand; 

  public Sprite(Component component,
                Image image,
                Point position,
                Point motionVector){

    //Seed a random number generator 
    // for this sprite with the sprite
    // position.
    rand = new Random(position.x);
    this.component = component;
    this.image = image;
    setSpaceOccupied(new Rectangle(
          position.x,
          position.y,
          image.getWidth(component),
          image.getHeight(component)));
    this.motionVector = motionVector;
    //Compute edges of usable graphics
    // area in the Frame.
    int topBanner = (
                 (Container)component).
                       getInsets().top;
    int bottomBorder = 
                ((Container)component).
                    getInsets().bottom;
    int leftBorder = (
                (Container)component).
                     getInsets().left;
    int rightBorder = (
                (Container)component).
                    getInsets().right;
    bounds = new Rectangle(
         0 + leftBorder,
         0 + topBanner,
         component.getSize().width - 
            (leftBorder + rightBorder),
         component.getSize().height -
           (topBanner + bottomBorder));
  }//end constructor
  //---------------------------------//

  public Rectangle getSpaceOccupied(){
    return spaceOccupied;
  }//end getSpaceOccupied()
  //---------------------------------//
  
  void setSpaceOccupied(
              Rectangle spaceOccupied){
    this.spaceOccupied = spaceOccupied;
  }//setSpaceOccupied()
  //---------------------------------//
  
  public void setSpaceOccupied(
                       Point position){
    spaceOccupied.setLocation(
               position.x, position.y);
  }//setSpaceOccupied()
  //---------------------------------//
  
  public Point getMotionVector(){
    return motionVector;
  }//end getMotionVector()
  //---------------------------------//
  
  public void setMotionVector(
                   Point motionVector){
    this.motionVector = motionVector;
  }//end setMotionVector()
  //---------------------------------//
  
  public void setBounds(
                     Rectangle bounds){
    this.bounds = bounds;
  }//end setBounds()
  //---------------------------------//
  
  public void updatePosition() {
    Point position = new Point(
     spaceOccupied.x, spaceOccupied.y);
    
    //Insert random behavior.  During 
    // each update, a sprite has about
    // one chance in 10 of making a 
    // random change to its 
    // motionVector.  When a change 
    // occurs, the motionVector
    // coordinate values are forced to
    // fall between -7 and 7.  This 
    // puts a cap on the maximum speed
    // for a sprite.
    if(rand.nextInt() % 10 == 0){
      Point randomOffset = 
         new Point(rand.nextInt() % 3,
                   rand.nextInt() % 3);
      motionVector.x += randomOffset.x;
      if(motionVector.x >= 7) 
                   motionVector.x -= 7;
      if(motionVector.x <= -7) 
                   motionVector.x += 7;
      motionVector.y += randomOffset.y;
      if(motionVector.y >= 7) 
                   motionVector.y -= 7;
      if(motionVector.y <= -7) 
                   motionVector.y += 7;
    }//end if
    
    //Move the sprite on the screen
    position.translate(
       motionVector.x, motionVector.y);

    //Bounce off the walls
    boolean bounceRequired = false;
    Point tempMotionVector = new Point(
                       motionVector.x,
                       motionVector.y);
    

    //Handle walls in x-dimension
    if (position.x < bounds.x) {
      bounceRequired = true;
      position.x = bounds.x;
      //reverse direction in x
      tempMotionVector.x = 
                   -tempMotionVector.x;
    }else if ((
      position.x + spaceOccupied.width)
          > (bounds.x + bounds.width)){
      bounceRequired = true;
      position.x = bounds.x + 
                  bounds.width - 
                   spaceOccupied.width;
      //reverse direction in x
      tempMotionVector.x = 
                   -tempMotionVector.x;
    }//end else if
    
    //Handle walls in y-dimension
    if (position.y < bounds.y){
      bounceRequired = true;
      position.y = bounds.y;
      tempMotionVector.y = 
                   -tempMotionVector.y;
    }else if ((position.y + 
                  spaceOccupied.height)
         > (bounds.y + bounds.height)){
      bounceRequired = true;
      position.y = bounds.y + 
                 bounds.height - 
                  spaceOccupied.height;
      tempMotionVector.y = 
                   -tempMotionVector.y;
    }//end else if
    
    if(bounceRequired)
      //save new motionVector
                   setMotionVector(
                     tempMotionVector);
    //update spaceOccupied
    setSpaceOccupied(position);
  }//end updatePosition()
  //---------------------------------//
  
  public void drawSpriteImage(
                           Graphics g){
    g.drawImage(image,
                spaceOccupied.x,
                spaceOccupied.y,
                component);
  }//end drawSpriteImage()
  //---------------------------------//
  
  public boolean testCollision(
                    Sprite testSprite){
    //Check for collision with 
    // another sprite
    if (testSprite != this){
      return spaceOccupied.intersects(
        testSprite.getSpaceOccupied());
    }//end if
    return false;
  }//end testCollision
}//end Sprite class
//===================================//

Listing 6

About the author

Richard Baldwin is a college professor and private consultant whose primary focus is a combination of Java and XML. In addition to the many platform-independent benefits of Java applications, he believes that a combination of Java and XML will become the primary driving force in the delivery of structured information on the Web.

Richard has participated in numerous consulting projects involving Java, XML, or a combination of the two.  He frequently provides onsite Java and/or XML training at the high-tech companies located in and around Austin, Texas.  He is the author of Baldwin's Java Programming Tutorials, which has gained a worldwide following among experienced and aspiring Java programmers. He has also published articles on Java Programming in Java Pro magazine.

Richard holds an MSEE degree from Southern Methodist University and has many years of experience in the application of computer technology to real-world problems.

baldwin.richard@iname.com






Comment and Contribute

 


(Maximum characters: 1200). You have characters left.

 

 


Sitemap | Contact Us

Rocket Fuel