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

There are two details I need to point out. First, the
Character
class is extending the
Sprite
class.

This means that any game objects you make using the
Character
class are actually
Sprite
objects under their skin. The
extends
keyword means that the
Character
class has
inherited
all the properties and methods of the
Sprite
class. It means that you can use all the same properties and methods that you usually use with
Sprite
objects. Properties like x, y, visible, alpha, or methods like
addChild
will all work with any objects that you make with this new
Character
class.

It also means that you don't have to create a separate
Sprite
object and add the image to it. The image is already wrapped inside a
Sprite
because the
Character
extends the
Sprite
class.

All of this means that
Character
objects will be able do everything that
Sprite
objects can, with the bonus that they display the image of the game character.

But where is the character.png actually being displayed? It's not being displayed on the stage. It's being displayed inside
this
class. That's what this line does:

The keyword
this
means “this class.” This line of code means that you're adding the
gameObjectImage
to
this
,
Character
, class. The result is that whenever you use a
Character
class object in a game, the character.png image will automatically be displayed. It's part of the class.

Why didn't you use
stage.addChild()
like you've done in other programs? That's because only the application class can add things directly to the stage. The application class, in this case, is
TimeBombPanic.as
. You'll see how it will add a
Character
class object to the stage very soon.

So now you know that the
Character
class just has the job of displaying the character.png image. But what do the
Bomb
,
Box
,
Background
, and
GameOver
classes do? Exactly the same thing: they display the images you designed in the first part of the chapter. In fact, the code in each is almost identical. Take a look at the
Box
class.

The only difference between the
Box
class and the
Character
class is the name and the PNG file that it's embedding. Browse through the other classes and you'll see that they all follow this identical format.

So now that you've got these classes and stuffed your game graphics inside them, how do you use them? You first have to make objects from them, and you can do this in the application class.

Of course you already know how to make objects: with the
new
keyword. You can make an object from the
Character
class like this:

You can then add it to the stage like this:

You can now use the
character
object anywhere you like in your game, and it will work like any other
Sprite
object you've ever created. But the one bonus is that it will already contain the character.png image.

Where this saves you a lot of work is if you have to make multiple copies of an object. There are 14 boxes in Time Bomb Panic. You don't need to make 14 separate classes for each box. You just need one parent
Box
class and you can make 14 instances (copies) of it. Each of those instances will automatically contain the embedded box.png image. This saves you having to type out dozens of lines of repetitive code.

Here's how you can make multiple box instances using just one
Box
class. First, make a few
box
objects in the application class.

You can add them to the stage like this:

There's not a single Embed metatag in sight!
box1
,
box2
, and
box3
will all contain the box.png image that was embedded into their parent
Box
class.

Do you see now how classes are just “things” in your game?

These five simple classes have just contained images, but you can put anything you like into a class. In the next chapter, you'll see how to put logic code inside them so that you can create objects with very complex, autonomous behavior.

Figure 7-76
illustrates how these object classes work with the application class to produce the images that you can see on the stage.

Figure 7-76
. The application class makes game objects from the game object classes.

Now that you know your five game objects are self-contained classes, let's take a look at the entire
TimeBombPanic
application class, and I'll show you how they've been used in the game.

I'm going to list the entire
TimeBombPanic
application here so that you have a reference to it for the rest of the chapter. You'll recognize some very familiar code, but a few new things as well. I'll walk you through exactly how all of it works.