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

Figure 8-14 illustrates the
Star
class's public properties and methods.

Figure 8-14.
The star's public properties

But because the star needs to spin around its center, the
_starImage
needs to be centered. This is easily done with two lines of code that subtract half the star images' height and width from its x and y position. This neatly centers the image.

Because the star image is now centered, its spin axis will be its center point. If the star image isn't centered like this, the spin axis will be its top left corner and the spin effect will be lopsided.

When the player presses the space key on the keyboard, the
onKeyDownHandler
sets the star's launched property to true. It does this only if launched isn't already true so that the star isn't launched more than once while it's on the stage.

This code also centers the star on the character.

If the star has been launched, the
enterFrameHandler
then runs this code:

This code makes the star visible, moves it, rotates it, checks its stage boundaries, and checks for collisions with the monsters. If the launched property is false, this code also makes the star invisible. As you'll soon see, the launched property is set to false when the star hits the stage boundary or any of the monsters.

Because the star only moves upwards, the code that checks its stage boundaries only needs to check for a collision with the top of the stage. The
checkStarStageBoundaries
method does this:

It sets the star's launched property to false if it hits the top playing field boundary.

The
starVsMonsterCollision
method checks for collisions between the star and the monsters. It takes two arguments: the star and the monster that you want to check for a collision against.

The method's function definition will only check for a collision if the monster being checked is visible. (If it's invisible, it means it's already been hit three times and has been removed from the game.) If the monster is visible, the code does the following things:

• Opens the monsters mouth.
  
• Adds 1 to the monster's timesHit property.
  
• Sets the star's launched property to false.
  
• Checks whether the monster has been hit three times; if it has, it calls the
  killMonster
method.
  
• If the monster has been hit three times, it also calls the
  checkGameOver
method to find out if the game is possibly finished.
  

Here's the
starVsMonsterCollision
method that does all this work:

This is an interesting bit of code because it changes one property in the star, two properties in the monsters, and calls two methods in the
LevelOne
class.
Figure 8-15
shows how all these connections fit together.

Figure 8-15.
What happens when the star hits the monster

You'll look at the
checkGameOver
method in detail soon, but first take a look at what happens when one of the monsters is hit three times.

If the star hits one of the monsters three times, the
killMonster
method is called. It performs the following tasks:

• Makes the monster invisible.
  
• Creates an explosion object from the
  Explosion
class and adds it to the stage.
  
• Centers the explosion over the monster's current position.
  
• Calls the explosion object's
  explode
method. This makes the explosion image appear and then disappear again after two seconds.
  

Here's the
killMonster
method that does all this:

This is the first time you've seen how you can create an object while the game is in progress. All the other game objects, like
_star
,
_character
,
_monster1
, and
_monster2
, were created when the game was initialized. The explosion objects are created by the
killMonster
method whenever they're needed, like this:

This new explosion object is
local
to the
killMonster
method. That means that you can only access it inside this method. You can't refer to this new
explosion
object anywhere else in the class. That's just fine because it's just a simple visual effect that you don't need to use anywhere else. You also don't know how many explosion objects you'll need before the game starts, so this method will make a new one whenever you need it, whether that's 1 or 100. You don't need to plan this in advance by creating all the explosion objects when you initialize the game.

After this new
explosion
object is created, it's centered over the monster's current position.

Finally, the
explosion
object's
explode
method is called.

This makes the explosion image visible for two seconds and then makes it invisible again. All this is done with a timer in the
Explosion
class, and it uses exactly the same technique you used to make the monster open and close its mouth.

Here's the entire
Explosion
class with its public
explode
method that starts the timer that makes the image visible:

Figure 8-16 illustrates the Explosion class's properties and methods.

Now that you know how all the objects in the game work, let's see how the code determines whether or not the level has been finished.

Figure 8-16.
The Explosion class

The level is completed when the character has been hit once by the monsters or each of the monsters has been hit three times by the player's star. As you saw in the previous example, when this happens, the code calls the
checkGameOver
method.