ActionScript 3.0 101

[CyanBlue]

Sweet... Appreciate it... and keep it coming...

[matbury]

How about some syntax for sharing variables between classes?

i.e. getter and setter methods, accessing public variables, etc.

[FrodoBaggins]

Thanks!
Here's one more for today.

Accessing a loaded SWF
It's not that hard actually. It's a matter of loading one swf in the other and assign it to a variable. Than use that variable to call the functions in the loaded swf. For this example we'll load b.swf in a.swf

code on frame 1 in b.swf:

function sayHi() {
   trace("b.swf says hi!");
}

code in a.swf:

import flash.display.Loader;
import flash.net.URLRequest;
import flash.events.*;
    
var loader:Loader;
var req:URLRequest;
var loadedSWF:Object;

loader = new Loader();
addChild(loader);
            
req = new URLRequest("b.swf");
loader.load(req);

// check when we're done loading        
loader.contentLoaderInfo.addEventListener(Event.INIT, initHandler);

function initHandler(e:Event):void {
    loadedSWF= loader.content;
    // call the sayHi function from the loaded b.swf
    loadedSWF.sayHi();
}

NOTE: We use Event.INIT because that event is called when the first frame of the loaded file (ie: if its a SWF) is loaded, which means that all your functions are available. Event.COMPLETE is is called when the file is done loading ie: 100%. Slight difference, but can proof pretty fatal.

Thanks to bzouchir: http://actionscript.org/forums/showthread.php3?t=151392 (This thread also digs into the subject a bit deeper.)

The Loader class on liveDocs: http://livedocs.adobe.com/flash/9.0/...ay/Loader.html

[matbury]

How about if you create an array in one class (i.e. CreateArray.as) and you want to access it in another class (i.e. UseArray.as)?

[FrodoBaggins]

Come on mat, you know how that works, now show me!

[Takster]

I just added some code to post number seven so people can copy and paste it into the first frame of a AS3 file and get it to work. No need to make a class file unless you want to, which would require extra work to get working . Also there is a typo in the removeEventListener. You are trying to remove a method that has not been defined, (onMouseMove). To see how well this works, publish the file at 1fps. After you run it comment out line 30: e.updateAfterEvent(); and then run it again. Great idea for a thread by the way. Kudos to FrodoBaggins.

import flash.display.MovieClip;
import flash.display.Graphics;
import flash.events.*;

var myMC:MovieClip = new MovieClip;

myMC.graphics.beginFill(0xff0000,1);
myMC.graphics.drawRect(0,0,100,100);
myMC.graphics.endFill();
addChild(myMC);

myMC.addEventListener(MouseEvent.MOUSE_DOWN, mouseDownHandler) 
myMC.addEventListener(MouseEvent.MOUSE_UP, mouseReleasedHandler);

// create Rectangle object
var bounds:Rectangle = new Rectangle(0,0, 450, 300);

function mouseDownHandler(e:MouseEvent):void {
    // changed for limited movement.
    myMC.startDrag(false, bounds);;
    stage.addEventListener(MouseEvent.MOUSE_MOVE, mouseMoveHandler);
}

function mouseReleasedHandler(e:MouseEvent):void {
    myMC.stopDrag();
    stage.removeEventListener(MouseEvent.MOUSE_MOVE, mouseMoveHandler);
}

function mouseMoveHandler(e:MouseEvent):void{
    e.updateAfterEvent();
}

[ryryguy]

ActionScript 3.0 adds a number of features to support object-oriented ("OO") programming. Even if you are not creating lots of your own classes, much of ActionScript 3.0's functionality is built into a set of classes that have established inheritance relationships. To use these Flash classes effectively, it's essential to understand how types and typecasting work.

Look at the DisplayObject class, for an example. DisplayObject has the following direct subclasses:

• AVM1Movie
  Bitmap
  InteractiveObject
  MorphShape
  StaticText
  Video

And that's only the subclasses that extend DisplayObject directly. If you look at subclasses of subclasses, you'll find that (among others) Loader, Sprite, and Stage are also indirect subclasses of DisplayObject ("great grandchildren" if you like: DisplayObject -> InteractiveObject -> DisplayObjectContainer -> Sprite). MovieClip is another indirect subclass of DisplayObject (through Sprite).

Point #1: Objects can be treated as if they are objects of any of its parent classes. So, for the following DisplayObjectContainer method:

addChild(child:DisplayObject)

the argument "child" can be a Bitmap, or a Loader, or a StaticText, or any other subclass of DisplayObject. All of these things, in an important sense, are DisplayObjects.

Point #2: Objects cannot be treated as if they were objects of a particular subclass without typecasting. The situation described in point 1 doesn't work when you move in the other direction. While you can treat a MovieClip as a DisplayObject, you can't take a DisplayObject and use it as a MovieClip. For example, the following code would fail (would not compile):

function playClip(clip:DisplayObject):void
{
    clip.gotoAndPlay(0);  // doesn't work - "clip" is a DisplayObject, not a MovieClip!
}

Note that in the "playClip" example, the object pointed to by the argument "clip" might actually be a MovieClip, as it would be if you called it like this:

playClip(new MovieClip());

However, even if that is the case, the variable "clip" still has the type "DisplayObject", and that type does not have a "gotoAndPlay" function.

Point 3: Typecasting can convert a variable of a superclass type into a variable of a subclass type. Typecasting is a way of translating or recharacterizing a variable into a related type. There are a couple of ways to do this, but I prefer the "is" and "as" operators. Here's the "playClip" example modified to use the typecasting operators:

function playClip(clip:DisplayObject):void
{
    if( clip is MovieClip )
    {
        var mc:MovieClip = clip as MovieClip;
        mc.gotoAndPlay(0);  // "mc" is type MovieClip, so we can call gotoAndPlay
    }
    else
    {
        trace("Error, " + clip + " is not a MovieClip.");
    }
}

The "as" operator will just return null if the thing you're trying to cast is not actually an object of the requested type, so you don't even really have to use the "is" operator in this example:

function playClip(clip:DisplayObject):void
{
    var mc:MovieClip = clip as MovieClip;
    if( mc != null )
    {
            mc.gotoAndPlay(0);  
    }
    else
    {
        trace("Error, " + clip + " is not a MovieClip.");
    }
}

Finally, a common real-world scenario. Suppose that you have made a custom class, "MyDocument", that you are using as the document class for a Flash file:

package pkg {
    public class MyDocument extends MovieClip
    {
        public var filenames:Array;

        public function reloadFile(var filename:String):void
        { 
            //...
        }
    }
}

That means that for objects put on the stage in the flash file, the "root" object will be a MyDocument. However, the "root" property is still of type DisplayObjectContainer, so it cannot be used to access MyDocument functions or properties without typecasting:

// this code is on the timeline of a MovieClip symbol we are placing on the stage.

import pkg.MyDocument;

function updateStatus():void
{
    var theDocument:MyDocument = root as MyDocument;
    if( theDocument == null )
    {
        trace("error, root isn't a MyDocument!");
        return;
    }
    
    for each( var filename in theDocument.filenames )
    {
        if( isFileOutOfDate(filename) )
        {
            theDocument.reloadFile(filename);
        }
    }
}

Live docs page: http://livedocs.adobe.com/flash/9.0/main/00000045.html

[gggmork]

Originally Posted by Takster

I just added some code to post number seven...

Thanks, something simple like this will be useful for me to study; saved it. Also, something related to making it usable in a fla-only file... isn't there an easy way to dedent (de-tabify) selected text in as3? For example if I first make something the 'class' way with a seperate as file, but later want to make it usable in a fla-only file, I would probably want to delete the 'package' line and remove that indentation. I didn't see any way to remove indentation though.

[FrodoBaggins]

Whoohoo, this thread got sticky!
First thing I'll do now is adding a small index in my first post to easily find subjects.

@matbury: I'll create an example later today on accessing class members.

@Takster: Thanks for pointing out those typo's, I couldn't test here, but I'll dl the cs3 trial and use that for a while.

@ryryguy: Thanks for your contribution!

[FrodoBaggins]

On special request, getter and setter methods.

Let's say we're building a race game and we want to be able to set the player's name and also retrieve it to, say, put it on the licence plate.

There are three ways of setting and retrieving a class's variables.
(This is not really as3 only, the same applies to as2.)

1. Make the variable public:

// Player.as
package awesomeRaceGame {
    
    public class Player {
        
        // the player's name
        public var pname:String;
        
        /*
         * empty constructor
         */
        function Player(){
            
        }
    }
}

// on timeline or other class
import awesomeRaceGame.Player;
var myPlayer:Player = new Player();
myPlayer.pname = "Frodo";
trace(myPlayer.pname);

2. Make the variable private, but use public functions to access the variable.

// Player.as
package awesomeRaceGame {
    
    public class Player {
        
        // the player's name
        private var pname:String;
        
        /*
         * empty constructor
         */
        function Player(){
            
        }
        
        /*
         * function that sets the racer's name
         *
         * @n: the name
         */
        public function setPlayerName(n:String):void {
            pname = n;
        }
        
        public function getPlayerName():String {
            return pname;
        }
    }
}

// on timeline or other class
import awesomeRaceGame.Player;
var myPlayer:Player = new Player();
myPlayer.setPlayerName("Frodo");
trace(myPlayer.getPlayerName());

3. Using Flash's get and set methods (aka an in between 1 & 2).

// Player.as
package awesomeRaceGame {
    
    public class Player {
        
        // the player's name
        private var pname:String;
        
        /*
         * empty constructor
         */
        function Player(){
            
        }
        
        /*
         * function that sets the racer's name
         *
         * @n: the name
         */
        public function set pname(n:String):void {
            pname = n;
        }
        
        public function get pname():String {
            return pname;
        }
    }
    
}

// on timeline or other class
import awesomeRaceGame.Player;
var myPlayer:Player = new Player();
myPlayer.pname = "Frodo";
trace(myPlayer.pname);

Method 1 is considered bad OO practice, though some programmers argue that it is awkward to use method two. Using this method there is no control over what value can be assigned to your variable.

Method 2 is my personal favorite. The variable is private, but accessable through public methods. The methods in turn can prevent assignment of illegal values. Say we have only 15 characters available for our player name on the licence plate. We could modify the setPlayerName function to truncate the name to 15 characters.

Method 3 has the same benefits as 2, but also takes a step towards the ones in favour of method one. You can assign variables without explicitely calling a function.