RiverMan Media

 Behaviors in Action

public class Monkey extends GameObject implements ActionListener
{
  // NOTE: extending GameObject gives Monkeys a bunch of generic
  // methods like getX(), getY(), setImage(), etc, and implements
  // simple related interfaces, like Moves, Draws, etc.

  private AnimationBehavior walk;
  private AnimationBehavior jump;
  private MotionBehavior motion;
  private ClickBehavior clickMe;

  private int state = 0; 
 
  // states
  private static final int  
    FOLLOWING = 0,  // following the character
    CLIMING = 1,    // climbing a vine
    FALLING = 2;    // free-falling or rising after a throw

  public Monkey()
  {
    // The monkey is both the parent and the listener.
    walk = AnimationBehavior(this, 5, Graphics.monkeyWalkImgs, this);
    walk.setActive(true);

    jump = AnimationBehavior(this, 5, Graphics.monkeyJumpImgs, this);
    jump.setActive(false);   

    // This behavior operates the motion of the monkey while it's
    // in the air.
    motion = MotionBehavior(this);
    motion.setActive(false);

    // Reports when the monkey is clicked.
    // Parameters: (parent, listener).
    clickMe = ClickBehavior(this, this)
    clickMe.active = true;
  }

  public void update()
  {
    // Only the behaviors that are active will actually update.
    // Of course, you could do a switch on the monkey state and 
    // pick the ones you want to update that way.    
    walk.update();
    jump.update();
    motion.update();
    clickMe.uopdate();

    if (state == FALLING && groundCollision() == true)
    {
      state = FOLLOWING;
      motion.setActive(false);
      walk.reset();
    }
  }

  public void throwMe()
  {
    state = FALLING;
    motion.setActive(true);
    motion.setYVel(-15);  // propell the monkey upward
    motion.setYAccel(GRAVITY_CONSTANT);  // apply gravity

    jump.reset();
  }

  // Reset the walk animation here.
  // You could also build a repeating option into the behavior
  // itself.
  public void eventCallback(ActionEvent caller)
  {
    if (caller == walk)
    {
      walk.reset();
    }
    else if (caller == clickMe)
    {
      GameSounds.playMonkeyYell();
    }
  }
}

What we've got so far is just a fraction of what monkeys need to do.  But let's take a look at all that we've accomplished already, with a very small number of statements:

• The monkey plays its whole jump animation automatically when it's thrown, and stops it when the animation is over.
• The monkey plays its walk animation while it's walking, and repeats the animation by listening to its callback.
• MotionBehavior provides upward velocity to the monkey when it's thrown, and automatically applies gravity to the monkey while it's in the air.
• The monkey will start walking again once it lands on the ground and engage its walking animation.
• ClickBehavior automatically detects when the monkey is clicked, and the monkey makes a sound.  Okay, this isn't actually in the game, but I wanted to show you how easy it is to make any object into a widget.

The behaviors have kept this Monkey class short, organized, bug-resistant, flexible, and simple to code.  The behavior system standardizes the interface to all of this additional functionality so that you don't have to think about it once you've coded it the first time.

Behaviors Vs. Robot Functions

Robot Functions and Behaviors are similar in that they extend the capabilities of a parent object.  They also both make a callback to a listener when they finish their task.  Here are the key differences between the two:

1. Robot Functions only have a access to one variable of the parent.  Behaviors may have access to all of the parent's variables and methods.
2. Robot Functions always have a pre-determined end, but not all behaviors do.
3. Robot Functions just define a special curve for altering a value, whereas Behaviors can do much more with their input.
4. A Behavior may contain Robot Functions to complete its work, but Robot Functions would never contain Behaviors.

When all you need to do is operate on specific variables over time (such as scale, alpha, position, etc.) use Robot Functions.  When you want more complex capabilities or need to coordinate several Robot Functions, use Behaviors.

---

Behaviors by themselves have been a huge asset to my game programming, but I've only shown you HALF of the power of behaviors.  The other half comes when they are used in the context of the Scripted Event System.  If you like the concept behind Behaviors and Robot Functions, you'll really want to check out that article to truly see them in action.

Want to read more?  Here's a link to the first ever discussion of Behaviors at Gamedev.net:
http://www.gamedev.net/community/forums/topic.asp?topic_id=492938&PageSize=25&WhichPage=1