By longstanding convention, class names begin with a capital letter. If the class name is composed of more than one word, this convention is applied to each word and spaces are removed, which is why, for example, “movie clip” becomes MovieClip. Though perfectly acceptable from a technical standpoint, advanced programmers may cringe at a class named bottle, so to stay consistent with recommended best practices, you may want to rename your linkage classes accordingly. In this case, the change would be Bottle, and the instantiation would changes as follows:

var asset:Bottle = new Bottle();

If your asset’s library name happens to contain spaces—for example, “floating bottle”—the authoring tool removes those spaces for you, suggesting floatingbottle as your class name, in which case the manual change to FloatingBottle not only defers to convention but also makes the class name easier to read.

In addition to spaces, many other characters are not allowed in class names. Like variables, class names can’t begin with a number or any punctuation other than an underscore (_) or dollar sign ($). If your library asset happens to include invalid characters, you see the warning shown in Figure 7-7 when you click OK in the Symbol Properties dialog box.

Figure 7-7. Class names must contain valid characters

In most cases, you can stick with the base class supplied automatically for you in the Base class field of the Symbol Properties dialog box. The authoring tool is smart enough to recognize the file format of the associated asset and, for example, suggests the following base classes for various types of assets:

If a movie clip symbol contains only one frame and no nested multiframe assets, then it effectively meets the criteria of a sprite, and you may change its base class accordingly (Figure 7-8). By extending the Sprite class, your asset avoids the slight memory overhead of the MovieClip class.

Figure 7-8. Simple, one-frame movie clip symbols may be configured to extend Sprite

If you like, you can write your own class to provide additional functionality for an attached asset. Custom classes must extend the same base class displayed in the Symbol Properties dialog box.

To make the submerged bottle drift back and forth, for example, you could write something like the custom FloatingBottle class that follows, which extends Sprite:

package {
    import flash.display.Sprite;
    import flash.events.Event;
    public class FloatingBottle extends Sprite {
        private var _driftCounter:Number;
        // constructor
        public function FloatingBottle() {
            _driftCounter = 0;
            addEventListener(Event.ENTER_FRAME, drift);
        }
        private function drift(evt:Event):void {
            _driftCounter += 0.12;
            this.x += Math.cos(_driftCounter) * 2;
        }
    }
}

In this case, the Class field in the Symbol Properties dialog box must be set to FloatingBottle and the Base class must be set to flash.display.Sprite, as shown in Figure 7-9.

Figure 7-9. Custom classes are entered by hand

The actual class file, FloatingBottle.as, must appear in same folder as the FLA file if no package is provided in the Class field. If your class file exists elsewhere, be sure to include its package information in the Symbol Properties dialog box.

To verify that the custom class is available, in the Symbol Properties dialog box, click the green checkmark button next to the Class field. Doing so gives you a message that tells where the class was found or that one will be automatically generated upon export. The pencil button opens the associated class file in a Script window of the authoring tool (Figure 7-10). No warning is given for custom classes when you click the OK button, because the authoring tool doesn’t have to write a class for you.

Figure 7-10. The pencil button next to the Class field opens the associated class file

The instantiation of assets based on custom classes is no different from those with automatically generated classes. The following lines attach the same bottle library asset, positioning it slightly lower than the center of the stage. This time, the bottle drifts back and forth because a frame loop repeatedly executes the drift() method of the FloatingBottle class.

var fb:FloatingBottle = new FloatingBottle();
fb.x = (stage.stageWidth / 2) – (fb.width / 2);
fb.y = ((stage.stageHeight / 2) – (fb.height / 2)) + 50;
addChild(fb);

Because each type of asset represents its own class, instantiation must follow the rules that normally pertain to that class. A seagull photo imported into the library as seagull.png represents the BitmapData class. Assuming a default (automatically written) class is set as Seagull in the Symbol Properties dialog box, the asset can be added to the stage in conjunction with the Bitmap class, as is true of any BitmapData instance:

var sg:Seagull = new Seagull(150, 286);
var bmp:Bitmap = new Bitmap(sg);
addChild(bmp);

The BitmapData constructor function requires a width and height, here obtained from the Bitmap Properties dialog box for this asset. Right-click (Ctrl-click) an asset in the library, and then select Properties to open this dialog box. Notice, in Figure 7-11, that linkage properties are also available from this dialog box.

Figure 7-11. Bitmap dimensions can be obtained from the Bitmap Properties dialog box (seagull photo by Patrick Nijhuis, used with permission)

In this case, the bmp variable points to an instance of the Bitmap class, which features x and width properties, just like movie clips. To position the image before adding it to the display list, simply configure the desired properties (new code in bold).

var sg:Seagull = new Seagull(150, 286);
var bmp:Bitmap = new Bitmap(sg);
bmp.x = stage.stageWidth - bmp.width;
addChild(bmp);

An audio file imported into the library as waves.mp3 represents the Sound class. Assuming a default (automatically written) class is set as Waves in the Symbol Properties dialog box, the asset can be instantiated the same as any Sound instance:

var wv:Waves = new Waves();
wv.play();

With FloatingBottle, Seagull, and Waves attached to the SWF file at runtime, the SWF looks like Figure 7-12. (You’ll just have to trust that the bottle’s drifting, and roaring ocean waves are audible.)

Figure 7-12. A SWF file with dynamically attached assets (seagull photo by Patrick Nijhuis, used with permission)

One of the benefits of designing in Flash, as opposed to traditional HTML, is that SWF files can embed fonts. While you don’t need ActionScript to use embedded fonts, you can certainly instantiate text fields dynamically and format them with instances of the TextFormat or StyleSheet classes, which, in turn, can reference fonts stored in the library.

To embed a font and make it available to ActionScript 3.0, use the following steps:

Figure 7-16. An embedded font in simple and HTML-formatted text