RiverMan Media

Implementing Behaviors

"Behavior" is an abstract superclass that all of your actual behaviors will extend.   Having all your behaviors extend this one class is very important--you'll see why in the context of the other systems.  The Behavior class just contains some basic variables and methods common to all behaviors.  The most important variable is an active boolean, which provides an easy way to turn the behavior on and off.  Important methods are update(), redraw() (although most behaviors don't use redraw, just leaving it empty), and eventCallback(), which I'll explain in a sec.  So let's see some code.  This is a basic example of how to implement the Behavior superclass:

One thing I haven't mentioned yet is why Behavior implements the ActionEvent interface and has a reference to a listener.  This is mostly for use in the Scripted Event System, as I'll show in that article, but is also helpful without any other systems.  You'll find that a lot of your behaviors have a defined beginning and an end, like how the FlipBehavior ends when the flipping action is finished.  For these behaviors, it makes sense that some object (usually the behavior's parent) will want to be listenting for the Behavior to finish so that it can either reset the behavior or let the behavior stop and take some other action.

The ActionListener interface just contains one method for listening to these generic event callbacks, called "eventCallback(ActionEvent e)."  The calling behavior is passed into this method so that the listener can figure out which behavior actually made the callback by comparing it to the behavior references that it owns.

A great example of a behavior that does use a listener is AnimationBehavior.  Often times, you want the object to cycle through it's set of animation frames, stop when it's done, and inform its parent.  Here is a very basic implementation of AnimationBehavior:

public class AnimationBehavior extends Behavior
{
  private Drawable parent;
  private Image[] animation;
  
  private double frameDuration;
  private int currFrame;
  private double currTime;
  
  public AnimationBehavior(Drawable setParent, double[] setFrameDuration,
      Image[] setAnimation, ActionListener setListener)
  {
    parent = setParent;
    frameDuration = setFrameDuration;
    animation = setAnimation;
    listener = setListener;

    currFrame = 0;
    active = true;
  }

  // Overriden from Behavior
  private void updateMe()
  {
    currTime += GET_TIME_PASSED();  // since the last update

    // time to change frames
    if (currTime >= frameDuration)
    {
      currTime -= frameDuration;
      currFrame++;
      
      // Advance the frame of the parent.
      if (currFrame < animation.length)
      {
        parent.setImage(animation[currFrame]);
      }
      // There are no frames left. The animation is done.
      else
      {
        behaviorDone(this);
        // active is now false, the parent is informed.
      }
    }
  }

  // Call this to start the behavior over.
  public void reset()
  {
    active = true;
    currFrame = 0;
  }
}

// Here's the tiny Drawable interface that the parent implements:
public interface Drawable
{
  public void setImage(Image newImg);
  public Image getImage();
}

Once you initialize this behavior with a parent and a set of images, all you have to do is call update() and the parent object will cycle through its animation frames.  When the animation is finished, it will inform its listener (if one is set) and stop animating on its own.

Here's another fairly common behavior that doesn't use a listener and doesn't have a defined stop time.  This one is used to move your objects around in space with acceleration and velocity.

public class MotionBehavior extends Behavior
{
  private double xVel = 0, yVel = 0;
  private double maxXVel = 10000, maxYVel = 10000;
  private double xAccel = 0, yAccel = 0;
  private CanMove parent;

  public MotionBehavior(CanMode setParent)
  {
    active = false;
    parent = setParent;
  }

  public void updateMe()
  {
    xVel += xAccel;
    yVel += yAccel;

    // Enforce the maximum velocities. When really coding this,
    // you'd need to make sure that the velocities don't go too
    // far negative either.
    if (xVel > maxXVel) xVel = maxXVel;
    if (yVel > maxYVel) yVel = maxYVel;

    parent.getX() = parent.getX() + xVel;
    parent.getY() = parent.getY() + yVel;
  }

  // Now just add getters and setters for the
  // velocities, max velocities, and accelerations.
  public void setXVel(double v) {xVel = v;}
  ...
}


// And here's the CanMove interface that the parent implements:
public interface CanMove
{
  public double getX();
  public double getY();
  public void setX(double x);
  public void setY(double y);
}