Foundation Game Design with ActionScript 3.0, Second Edition (83 page)

Here's how
checkGameOver
works:

• It finds out who won the game: the monsters or the character. It assigns this to a variable called
  _levelWinner
.
  

• It removes the
  enterFrameHandler
, which freezes all the action on the stage. If the character has lost, the code sets the character's
  alpha
to 0.5, which makes it semitransparent.
  

• It removes the monster timer's
  TIMER
event handler so that you stop assigning random directions to the monsters. It's important do this because the monster timer won't quit automatically when the level is finished. You don't want to waste precious CPU power running the timer if you don't need to.
  

• It starts the
  _gameOverTimer
, which calls
  gameOverTimerHandler
.
  

It's the
gameOverTimerHandler
that does the work of displaying the “Level Complete” message or “Game Over” message and informing the application class that the level has been finished. Let's see how this works next.

The
gameOverTimerHandler
introduces some new techniques.

• It uses the timer's currentCount property to perform a new action every two seconds.
  
• It announces that the level is complete so that the application class can load the second level.
  

Here's the
gameOverTimerHandler
that does this, and I'll explain how it works in detail next.

Let's first take a look at what happens when the monsters win the game because the code is very simple. The
_gameOverTimer
removes the
gameOverTimerHandler
so that all this code isn't called a second time.

The code also makes
_gameOver
object's
youLost
subobject visible.

The
_gameOver
object was added to the game by the
LevelOne
class when the class was initialized.

It's been sitting on the stage the whole time, but you couldn't see it because the subobjects that it contains have been invisible. The
GameOver
class contains two subobjects:
youLost
and
levelComplete
. Their visible properties are both set to false when they're added to their parent class. Here's the complete
GameOver
class that does this:

Figure 8-17 shows the effect that making the
_gameOver
object's
youLost
subobject visible has when the monsters win the game.

Figure 8-17.
Making the “You lost” message visible

So, if the monsters win, that's the end of the game and nothing else happens. Things get a lot more interesting if the character wins.

When the
_gameOverTimer
is created, it's initialized so that it calls the
gameOverTimerHandler
every two seconds.

As mentioned in
Chapter 7
, timers have a property called currentCount that counts the number of times the timer has run. In this example, the
_gameOverTimer
will increase its currentCount property by 1 every two seconds. The game uses this feature to manage displaying the “Level Complete” message and to load level two.

Then currentCount starts counting from 0 and the timer fires once every 2,000 milliseconds. That means that when it becomes 1, two seconds have already passed. When currentCount becomes 2, four seconds have passed. Here's how it's used to manage the transition from level one to level two:

• currentCount = 0: There's a two second pause at the end game when the
  enterFrameHandler
is removed by the
  checkGameOver
method. The
  checkGameOver
method also starts the
  _gameOverTimer
.
  
• currentCount = 1: The “Level Complete” message is displayed.
  
• currentCount = 2: Two seconds later, the code announces that the level is complete. The application class hears this and loads the game's second level. (The
  _gameOverTimer
is also reset.)
  

Figure 8-18 illustrates how the
_gameOverTimer.currentCount
property is managing the last four seconds of the game.

Figure 8-18
. The timer is used to end level one and transition to level two.

Here's the code in the
gameOverTimerHandler
method that actually does this:

You should now understand what this code is doing, except for this one very important line:

This bit of code is
dispatching an event
called
levelOneComplete
. It's broadcasting this message to the rest of the game that level one is finished. Any objects who are interested in this message can listen for it and perform some kind of action when they hear this event being broadcast.

The
MonsterMayhem
application class is extremely interested in this event because it needs to know when level one is finished. Let's take a look at the
MonsterMayhem
class again. I've highlighted all the code that adds a listener for the
levelOneComplete
event and the
switchLevelHandler
that takes some action when it hears it.

The
MonsterMayhem
application class listens for the
levelOneComplete
event by attaching an event listener to the stage.

The listener waits until this line of code is run by any object on the stage:

As soon as it hears this event, the application class runs its
switchLevelHandler
.

The
switchLevelHandler
does these things:

• It generates a trace message to let you know that this event is working. This is optional and just used for testing.
  

• It uses the
  removeChild
method to remove the
  _levelOne
object from the stage. It also gives the
  _levelOne
object a value of null, which clears it from the Flash Player's memory.
  

• It adds the
  _levelTwo
object to the stage.
  

Figure 8-19 shows how the
MonsterMayhem
application class can “hear” when
_levelOne
dispatches an event.

Figure 8-19.
Using events to switch levels

This is the first time you've seen how
removeChild
is used, and it's also the first time you've seen how a class can listen for an event being broadcast by another class. Let's take a slightly deeper look at these two new features.