Inspired by senocular's impressive "ActionScript 3 Tip of the Day" thread over at the Kirupa forums, I thought I would start something similar here at Ultrashock.

I will try to add an ActionScript tip, code snippet, example, etc, at least once a day to this thread and a few classes might also make an appearance. The ActionScript will range from AS2 to AS3 and may even include some prototype related snippets (even though I'm not keen on them).

I would like to try and keep this thread as tidy as possible (unlike the Full Screen Flash thread ), so please post any comments or questions in the ActionScript Tips Discussion thread.



Update
Our very own Codemonkey is now joining in with the fun, so expect this thread to expand quite rapidly.

Go monkey go monkey go!

[Nutrox]

 
If you ever need to remove all of the movie clips on a timeline you could use the following function. Keep in mind that this will only remove movie clips that have been added using attachMovie, createEmptyMovieClip, or duplicateMovieClip.

function removeChildren(parent:MovieClip):Void {
    var i:String;
    for (i in parent) {
        if (parent[i].removeMovieClip) {
            parent[i].removeMovieClip();
        }
    }
}
 
// Delete all of the movie clips in myMovieClip.
removeChildren(myMovieClip); 

Instead of using typeof to check if the object is a movie clip I am simply checking if the removeMovieClip method is available in the object. This should be quicker than using typeof.

[Nutrox]

 
The following function will allow you to align movie clips horizontally or vertically. You can also set the amount of spacing between each movie clip.

function alignClips(clips:Array, alignment:String, spacing:Number):Void {
    if (spacing == null) {
        spacing = 0;
    }
    var hori:Boolean  = alignment == "horizontal";
    var propA:String  = hori ? "_x" : "_y";
    var propB:String  = hori ? "_y" : "_x";
    var length:String = hori ? "_width" : "_height";
    var value:Number  = clips[0][propA];
    var i:Number      = 0;
    var n:Number      = clips.length;
    
    while (i < n) {
        clips[i][propA] = value;
        if (i) {
            clips[i][propB] = clips[i-1][propB];
        }
        value += clips[i++][length] + spacing;
    }
}
 
// Create an array and populate it with the movie clips
// that we want to align.
var myClips:Array = [mc1, mc2, mc3, mc4];
 
// Align the movie clips horizontally with 10px spacing.
alignClips(myClips, "horizontal", 10);
 
// or.. Align the movie clips vertically with 2px spacing.
// alignClips(myClips, "vertical", 5); 
 

[Nutrox]

 
Normally you would link a class to a library symbol if you wanted to add a class to a MovieClip. You can however take advantage of __proto__ if you want to add a class to a movie clip at runtime.

myMovieClip.__proto__ = new MyClass(); 

MyClass should extend MovieClip in the usual way.

The only downside to this is that physical changes to the movie clip don't seem possible from the class constructor. For example, this._x = 0 in the following class has no effect on the movie clip.

class MyClass extends MovieClip {
 
    public function MyClass() {
        this.onRollOver = rollOverHandler;
        this.onRollOut  = rollOutHandler;
 
        this._x = 0;
    }
 
    private function rollOverHandler():Void {
        this._xscale *= 2;
        this._yscale *= 2;
    }
 
    private function rollOutHandler():Void {
        this._xscale /= 2;
        this._yscale /= 2;
    }
 
} 

[Nutrox]

 
If you send variables to your Flash movie using flashVars the following function could be used to gather all of the variables up into an object. Number values are converted to true numbers, and you can also name your flashVars so they are recreated as arrays.

Here's the function:

function getFlashVars():Object {
    var o:Object = {};
    var n:String;
    var i:Number;
    var s:String;
    for (s in _level0) {
        if (s.substr(0,3) == "fv_") {
            n = s.substr(3);
            if (n.indexOf("_") > -1) {
                i = Number(n.split("_")[1]);
                n = n.split("_")[0];
                if (o[n] == null) {
                    o[n] = [];
                }
                if (isNaN(_level0[s])) {
                    o[n][i] = unescape(_level0[s]);
                }
                else {
                    o[n][i] = Number(_level0[s]);
                }
            }
            else {
                if (isNaN(_level0[s])) {
                    o[n] = unescape(_level0[s]);
                }
                else {
                    o[n] = Number(_level0[s]);
                }
            }
        }
    }
    return o;
} 

Here are a few examples of use. Note that each flashVar name is prefixed with fv_

01 - Basic example

HTML

<param name="flashVars" value="fv_foo=hello&fv_bob=123" />

AS

var info:Object = getFlashVars();
 
trace( info.foo ); // output: hello
trace( info.bob ); // output: 123
trace( typeof info.bob ); // output: number 
 

02 - Sending Arrays

To send an array to Flash you simply add _0 _1 _2 etc to the end of your variable name.

HTML

<param name="flashVars" value="fv_items_0=apple&fv_items_1=banana" />

AS

var info:Object = getFlashVars();
 
trace( info.items[0] ); // output: apple
trace( info.items[1] ); // output: banana 
 

[Nutrox]

 
If you want to be able to quickly and easily assign multiple functions to a movie clip's onEnterFrame event then the following code should give you something to play with.

var frameListeners:Array = [];
 
function addFrameListener(func:Function):Void {
    removeFrameListener(func);
    frameListeners.push(func);
    if (!this.onEnterFrame) {
        this.onEnterFrame = fireFrameListeners;
    }
}
 
function removeFrameListener(func:Function):Void {
    var i:Number = frameListeners.length;
    while (i--) {
        if (frameListeners[i] == func) {
            delete frameListeners.splice(i, 1);
            break;
        }
    }
    if (!frameListeners.length) {
        this.onEnterFrame = null;
    }
}
 
function fireFrameListeners():Void {
    var i:Number = 0;
    var n:Number = frameListeners.length;
    while (i < n) {
        frameListeners[i++]();
    }
} 

With those functions placed on the movie clip's timeline you can now add (and remove) your functions. All of the assigned functions will be called on each frame in the order you add them.

addFrameListener(functionOne);
addFrameListener(functionTwo);
 
//
 
function functionOne():Void {
   trace("function one");
}
 
function functionTwo():Void {
   trace("function two");
} 

That would result in the following trace on each frame:

-- function one
-- function two

Removing functions is done in the same way.

removeFrameListener(functionTwo); 

Keep in mind that these functions will use the movie clip's onEnterFrame event handler so if you manually assign a function to it then things will go pear shaped. For example, you shouldn't do something like this:

addFrameListener(someFunction);
 
this.onEnterFrame = function():Void {
   //
} 

[Nutrox]

 
Prototype functions can be used if you want to add functions to Flash's core classes such as String, Array, Number, and so on. When you create a prototype function, all instances of the prototyped class will be able to access the new function.

For example, let's say that you want to be able to reverse any of your strings at any time in your movie. To do that you would add a prototype function to the String class like this:

String.prototype.reverse = function() {
        var a = this.split("");
        a.reverse();
        return a.join("");
}; 

Now that the new function has been added you will be able to reverse any of your strings:

var myText = "Hello Ultrashock";
trace(myText); // output: Hello Ultrashock
 
myText = myText.reverse();
trace(myText);// output: kcohsartlU olleH 
 

Maybe you would like to be able to shuffle any of your arrays? Easy enough, you add your function to the Array prototype object like this:

Array.prototype.shuffle = function() {
    var a = [].concat(this);
    var i = a.length;
    var n;
    while (i--) {
        n = Math.floor(Math.random() * a.length);
        this[i] = a.splice(n, 1);
    }      
} 

Now you can shuffle any array in your movie:

var myItems = ["apple", "banana", "cherry", "doughnut"];
trace( myItems ); // output: apple,banana,cherry,doughnut
 
myItems.shuffle();
trace( myItems ); // output: doughnut,banana,apple,cherry 
 

You can add prototype functions to virtually any core class in Flash although it is better to create/use classes if you are able to.

[Codemonkey]

 
A lot of the time while debugging/profiling, you'll be interested in how many FPS your movie is actually pulling to see if there's something slowing it down.

Here's a class that let's you specify the update interval and invokes a method each time. You can drop this class in a util folder and use it in any of your projects:

import mx.utils.Delegate;
 
class util.FPS {
    private static var instance:FPS;
    private var time:Number;
    private var counter:Number;
    private var interval:Number;
    private var dummy:MovieClip;
    
    public var onUpdate:Function;
    
    public function FPS(interval:Number) {
        var d:Number = _root.getNextHighestDepth();
        this.dummy = _root.createEmptyMovieClip("fpsmc" + d, d);
        this.interval = interval;
        this.start();
    }
 
    // reset and start measuring
    public function start() {
        counter = 0;
        time = getTimer();
        dummy.onEnterFrame = Delegate.create(this, measure);
    }
 
    public function stop() {
        dummy.onEnterFrame = null;
        delete dummy.onEnterFrame;
    }
 
    // checks whether it should perform a measurement
    private function measure() {
        var now:Number = getTimer();
        var lapsed:Number = now - time;
        if (lapsed >= interval) {
            onUpdate(counter * (1000 / lapsed));
            time = now;
            counter = 0;
        }  
        counter++;
    }
} 

To use it:

import util.FPS;
 
// create FPS meter and update every 500ms
var fps:FPS = new FPS(500);
fps.onUpdate = function(fps:Number) {
    trace(fps);
} 

Don't set the interval too low though (min. 250ms) or the measurements become unreliable.

[Codemonkey]

 
To quickly convert a coordination in one movieclip to another movieclip, you can use the following function:

import flash.geom.Point;
 
function transCoord(coord:Point, from:MovieClip, to:MovieClip):Void {
        from.localToGlobal(coord);
        to.globalToLocal(coord);
    } 

This can come in handy for example when you need to move a movieclip to another movieclip that is not in the same container mc.

[Codemonkey]

 
If you have an indexed array (array with 1, 2, 3, 4, ... indexes) and you want to know the index of a certain object, you can use the following function:

// returns index of an item in array, -1 if it isn't in the array
    function inArray(array:Array, item:Object):Number {
        for (var i in array) {
            if (array[i] == item) {
                return Number(i);
            }
        }
        return -1;
    } 

If you want to remove a certain object from an array and want to know whether the object was found (and so removed) you can use the following method in conjunction with the previous one:

// tries to remove an item from array and returns whether it worked
    function arrayRemove(array:Array, item:Object):Boolean {
        var index:Number = inArray(array, item);
        if (index != -1) {
            array.splice(index, 1);
        }
        return index != -1;
    } 

Usage:

var names:Array = new Array("Bob", "Shirley", "Pete");
trace(arrayRemove(array, "Bob")); // traces "true"
trace(arrayRemove(array, "Bill")); // traces "false" 
 

---
You could also add these function to the Array class with prototyping as Nutrox explained in Tip 006. Or, you can add these methods to a global util class as explained in Tip 010

[Codemonkey]

 
If you have some functions you might use anywhere and possibly in different projects, you might want to create util classes from them. A util class is a class available from a global path with static methods only. Flash' Math class is a good example of this.

To create a util class start with an empty class like this:

class MyUtil {
} 

Then add your functions with the keywords public and static. Public so everyone can see them, static so everyone can access them through the classname without having to create an object first.

class MyUtil {
public static function MyUtilFunction(params_here):Number {
// do stuff with params and return result
}
} 

One benefit of having static methods only is that you acknowledge the functions do not depend on a state, which is the case a lot of the times with class instances (objects). This basically means you will only create one-shot functions that do a specific operation/calculation.

If you want to prohibit people from instantiating a utility class - which would also mean such a people didn't 'get' your utility class - you can add a private constructor:

class MyUtil {
private function MyUtil() {}
} 

Here's an example of a complete util class:

class ArrayUtils {
private function ArrayUtils() {}
 
// returns index of an item in array, -1 if it isn't in the array
public static function inArray(array:Array, item:Object):Number {
        [..]
}
 
// tries to remove an item from array and returns whether it worked
public static function arrayRemove(array:Array, item:Object):Boolean {
        [..]
}
} 

Usage:

var names:Array = new Array("Bob", "Shirley", "Pete");
trace(ArrayUtils.arrayRemove(array, "Bob")); // traces "true"
trace(ArrayUtils.arrayRemove(array, "Bill")); // traces "false" 
 

[Codemonkey]

 
To actually make your util class visible across your projects, you need to add it to your flash' IDE. To do this, go to:
Edit->Preferences->ActionScript->ActionScript Settings button.

In there, click the button "Browse to Path" to select the folder your util class is in. For example, my global path is "D:\MyStuff\Flash\local".

screenshot global paths

To use the global util class in your project, you can now just use a simple import statement without having to worry about whether it finds it:

// in this example ArrayUtils is in the directory/package "utils"
import utils.ArrayUtils; 

[Codemonkey]

 
If you quickly need a random number in a certain range, then you can use this simple (util) function:

function randomNum(min, max):Number {
        return min + Math.round(Math.random() * (max - min));
    } 

[Codemonkey]

 
If you want to make sure a number is within a certain range or clip it otherwise, here's a simple way to do this:

function clip(value:Number, min:Number, max:Number):Number {
        return Math.min(Math.max(value, min), max);
    } 

[Nutrox]

 
The following code is an example of how you could calculate the value for "bytes per second" and "remaining time" when loading external movies or images etc.

I will wrap this up in a class soon.

var loadTarget:MovieClip;
var loadTimer:Number;
var loadTotal:Number;
 
function loadClip(target:MovieClip, url:String):Void {
    loadTarget = target;
    loadTimer  = getTimer();
    loadTotal  = 0;
    target.loadMovie(url);
    this.onEnterFrame = updateLoadProgress;
}
 
function updateLoadProgress():Void {
    var bLoaded:Number = loadTarget.getBytesLoaded();
    var bTotal:Number  = loadTarget.getBytesTotal();
    if (bLoaded && bTotal) {
        if (bLoaded == bTotal) {
            this.onEnterFrame = null;
            onLoadComplete();
        }
        else if (getTimer() - loadTimer >= 250) {
            var bSec:Number = Math.round(bLoaded / (loadTotal / 1000));
            var tRemaining:Number = Math.round((bTotal - bLoaded) / bSec);
            onLoadProgress(bLoaded, bTotal, bSec, loadTotal, tRemaining);
            loadTimer = getTimer();
            loadTotal += 250;
        }
    }
}
 
function onLoadProgress(bLoaded:Number, bTotal:Number, bSec:Number,
                        tTotal:Number, tRemaining:Number):Void {
    trace("loaded progress: " + bLoaded + "/" + bTotal);
    trace("bytes per second (approx): " + bSec);
    trace("total time (approx): " + tTotal + " seconds");
    trace("remaining time (approx): " + tRemaining + " seconds");
    trace("");
}
 
function onLoadComplete():Void {
    trace("loaded!");
}
 
//
 
var container:MovieClip = this.createEmptyMovieClip("container", 0);
var url:String = "external.swf";
 
loadClip(container, url); 

[Codemonkey]

 
If you are working with Forms (mx.screens.Form), you can use this enhanced version to make your screens smoothly fade in/out when showing/hiding your form:

import mx.transitions.*;
import mx.transitions.easing.*;
 
// use this class on your forms instead
class codemonkey.util.BasicForm extends mx.screens.Form {
    private var __visible:Boolean = false;
    
    public function BasicForm() {
        this.addEventListener("allTransitionsInDone", this);
        this.addEventListener("allTransitionsOutDone", this);
        this.createEmptyMovieClip("bg", this.getNextHighestDepth());
    }
    // display form (show/hide)
    public function show(flag:Boolean) {
        if (flag != this.__visible) {
            this.__visible = flag;
            this.visible = (__visible) ? true : this.visible;
            var fadetype:Number = (flag) ? Transition.IN : Transition.OUT;
            TransitionManager.start(
this, {type:Fade, direction:fadetype, duration:1, easing:None.easeNone}
);
        }
    }
    // called by Flash' transition manager
    private function allTransitionsInDone(eventObj:Object) {
        this.visible = this.__visible;
    }
    private function allTransitionsOutDone(eventObj:Object) {
        this.visible = this.__visible;
    }
} 

To use this class, do as you normally would, but extend from the BasicForm class instead:

class LoadingScreen extends BasicForm {} 

screenshot of applying your form in Flash

[Codemonkey]

 
To create new sound objects that you can individually control, use can use the following function:

function loadSound(sound:String, vol:Number):Object {
    // create sound container
    var d:Number = _root.getNextHighestDepth();
    var emptyMC:MovieClip = _root.createEmptyMovieClip("empty" + d, d);
    // create sound
    var sound:Sound = new Sound(emptyMC);
    sound.attachSound(sound);
    sound.setVolume(vol);
    return sound;
} 

Usage:

var gunshot:Sound = loadSound("gunshot", 100);
var squeeky:Sound = loadSound("squeeky", 60); 

[Codemonkey]

 
To make the sound objects more manageble, you can embed it in a container that 'adds' functionality to a sound object. For example, you can simplify playing, status checks, looping etc. by adding functions for that to the sound's container.

Here's an example:

function loadSound(sound:String, vol:Number, loop:Boolean):Object {
    var d:Number = _root.getNextHighestDepth();
    var emptyMC:MovieClip = _root.createEmptyMovieClip("empty" + d, d);
 
// multifunctional container
    var SoundObj:Object = new Object();
    SoundObj.sound = new Sound(emptyMC);
    SoundObj.sound.attachSound(sound);
    SoundObj.sound.setVolume(vol);
    SoundObj.sound.onSoundComplete = function() {
        SoundObj.isPlaying = false;
    };
 
    SoundObj.isLoop = loop;
    SoundObj.isPlaying = false;
 
// only start playing when sound is not already playing
SoundObj.softStart = function(Play:Boolean) {
    if (Play) {
        if (!this.isPlaying) this.sound.start(0, this.isLoop ? 999 : 0);
    } else {
        if (this.isPlaying) this.sound.stop();
    }
 
    this.isPlaying = Play;
}
 
// restart playing no matter what
SoundObj.hardStart = function(Play:Boolean) {
    this.sound.stop();
    this.isPlaying = false;
    this.softStart(Play);
}
 
    return SoundObj;
} 

Ofcourse, you can add only so much until it becomes more logical to create a SoundClass instead and hide the details away in there.

[Nutrox]

 
Copy and paste the following code into a new Flash document for an instant clock. :)

var hourHand:MovieClip;
var minuteHand:MovieClip;
var secondHand:MovieClip;
var clockInterval:Number;
 
createClips();
updateClock();
clockInterval = setInterval(this, "updateClock", 500);
 
//
 
function updateClock():Void {
    var d:Date   = new Date();
    var h:Number = d.getHours();
    var m:Number = d.getMinutes();
    var s:Number = d.getSeconds();
    
    if (h >= 12) {
        // getHours returns a value between 0 and 23,
        // so we need to keep it within a 12 hour range.
        h -= 12;
    }
    
    hourHand._rotation   = (360 / 12) * h;
    minuteHand._rotation = (360 / 60) * m;
    secondHand._rotation = (360 / 60) * s;
}
 
function createClips():Void {
    var depth:Number = this.getNextHighestDepth();
    // Second
    secondHand = this.createEmptyMovieClip("secondHand", depth++);
    secondHand.lineStyle(2, 0xFF0000);
    secondHand.moveTo(0, -80);
    secondHand.lineTo(0, 0);
    // Minute
    minuteHand = this.createEmptyMovieClip("minuteHand", depth++);
    minuteHand.lineStyle(3, 0x00FF00);
    minuteHand.moveTo(0, -90);
    minuteHand.lineTo(0, 0);
    // Hour
    hourHand = this.createEmptyMovieClip("hourHand", depth);
    hourHand.lineStyle(5, 0x0000FF);
    hourHand.moveTo(0, -100);
    hourHand.lineTo(0, 0);
    
    // Position the movie clips.
    // Just move them to the center of the Stage for now.
    var x:Number  = Math.floor(Stage.width / 2);
    var y:Number  = Math.floor(Stage.height / 2);
    hourHand._x   = x;
    hourHand._y   = y;
    minuteHand._x = x;
    minuteHand._y = y;
    secondHand._x = x;
    secondHand._y = y;
} 

[Nutrox]

 
Normally you can't use removeMovieClip() on movie clips that you place on the Stage while authoring the movie. However, swap the movie clip depth to a positive value and removeMovieClip() will work fine!

function deleteClip(target:MovieClip):Void {
   var d:Number = target._parent.getNextHighestDepth();
   target.swapDepths(d);
   target.removeMovieClip();
}
 
// myMovieClip is already on the Stage
deleteClip(myMovieClip); 

[Codemonkey]

 
A less known and even less used feature in actionscript is the __resolve method.

If you declare a method called __resolve on your class and someone tries to call a property or method of your class that doesn't exist, flash will look for a __resolve instead and call that one. You will get a parameter with the name of the unknown property/method that the user is trying to call. In addition, you can use the arguments variable inside __resolve to uncover any arguments the user passed.

You can call properties/methods that don't exist on an object when:

1. Your class was declared dynamic

   dynamic class MyClass {
   function __resolve(name:String) {
   // do something
   }
   }
   var instance:MyClass = new MyClass();
   instance.unknownFunction() 

2. You use an Object directly

   var o:Object = new Object();
   o.__resolve = function (name) {
   // do something
   }
   o.unknownFunction() 

3. You typecast an instance of your non-dynamic class as Object (this won't work in AS3.0 though)

   class MyClass {
   function __resolve(name:String) {
   // do something
   }
   }
   var instance:MyClass = new MyClass();
   Object(instance).unknownFunction() 

__resolve can be useful in case you are creating dynamic classes for distribution and you want people to know when they called a non-existent function - which the compiler would've done if your class wasn't declared with the keyword dynamic. Or you could use __resolve to forward method calls to a server or act as an adaptor to other objects. In doing so you can also log all methods being called through __resolve in a single place. Another use is when you have a 'decorator' and you need to forward dynamic methods 1-on-1 to the 'decoratee'.

Be cautious though, __resolve doesn't *always* work as you would expect and you should have a very specific reason where you think __resolve is the solution.

[Codemonkey]

 
If you are creating your own components and you are extending an existing component class to do that, it may happen that you want to hide inherited public properties from the Component Inspector in Flash.

The answer is a Flash meta tag for components called InspectableList. While the component inspector knows what properties to list from each separate property that has Inspectable before it, you can override this list by using the InspectableList meta tag.

For example, when you know a component works with public x and y Numbers, but you want to work with a setPos() method and hide the x and y properties, you need a way to do this clean and simple (at least to users in the component inspector):

class ComponentA {
        [Inspectable(defaultValue=0)]
        public var x:Number;
 
        [Inspectable(defaultValue=0)]
        public var y:Number;
 
        [Inspectable(defaultValue=100)]
        public var size:Number;
} 

[InspectableList("size")]
class ComponentB extends ComponentA {
...
} 

In component B, the x and y properties are not available in the component inspector, but the property size still is. Be cautious though, if you use this tag to exclude variables, you have to add all the others by hand to this meta tag.

[Codemonkey]

 
There is no Tip 20.

[Codemonkey]

 
If you want a clean and efficient way of testing against flags, you can use bit-wise operators.

Define your flags as numbers like 2, 4, 8, 16 (double for each new flag constant):

var FUNNY = 2;
var NOISY = 4;
var HANDSOME = 8;
var COOL = 16;
var NERDY = 32;
var SUPERMANLIKE = 64; 

Then, you can combine these flags - and lateron check against individual flags - using the bitwise operator 'or':

var splat:Number = COOL | NERDY; // 'or' the bits!
var codemonkey:Number = FUNNY | HANDSOME | COOL | SUPERMANLIKE; 

To check if Splat is cool, use the bitwise operator 'and' to check the combined flags against the COOL flag:

if (splat & COOL) {
trace("Splat is cool!");
} 

The key to this mechanism is being able to use many different flags together in one number variable. Take the Array class for example. If you want to sort an Array with the method Array.sort(), you can use constants from the Array class to indicate how the sort should happen. Those constants are flag numbers you bitwise combine to quickly, cleanly and efficiently let the sort method know your needs.

---
You can store an entire chessboard in one variable, because there are 64 spaces in a chess board and you can have 64 different single bits in a Number (and each bit is represented by 2, 4, 8, etc...). Even better, you can do cool stuff like:

if (blackHorse & whitePieces) {
   // make black horse take whatever piece is occupying the same space
}

This principle is also known as bitboards, or boards of bits. It's one of the optimizations to make chess AI ultrafast.
---

[Codemonkey]

&nbsp
As you now know, you can combine flags to a combined flag, which means you join the ones '1' into a single number. Then you can check that number against a single flag whether it occurs.

To remove a single flag from such a combined number, you simply AND it with the opposite of the single bit flag. Huh? Take a look:

// combine flags:
var combinedFlag = ONE | TWO;
 
// remove single flag TWO:
combinedFlag = combinedFlag & ~TWO; 

It's very simple to code out, but understanding why it works needs a bit of digging.

---
With the '~' operator you can flip all zeros and ones so that the bit representation is exactly the opposite (ie. 11001 becomes 00110). AND'ing that to the combined flag means: keep everything of the original number, but throw away what's behind the AND. This works because that number has zeros '0' where the ones '1' were and AND'ing with zeroes won't work.

In math, there's actually a special operator for this kind of thing. instead of AND'ing with the opposite of a flag, you can NAND a flag. NAND stands for Not And, which is exactly the same.
---

Here's another example with a rabbit that drinks blood when it is full moon:

var HUNGRY = 2;
var THIRSTY = 4;
 
var WANT_CARROT = 8;
var WANT_CABBAGE = 16;
var WANT_WATER = 32;
var WANT_BLOOD = 64;
 
var rabbit:Number = HUNGRY | WANT_CARROT;
 
if (fullMoon) {
    // rabbit doesn't want to eat anymore
    rabbit = rabbit & ~HUNGRY;
    // rabbit is thirsty for blood now
    rabbit = rabbit | THIRSTY | WANT_BLOOD;
} 

[Codemonkey]

&nbsp
Sometimes it is useful to list all the single flags in a combined flag number. For example for debugging, logging or some other operation. You can do this by AND'ing all single flags by hand like this:

var FLAGONE = 1;
var FLAGTWO = 2;
var FLAGTHREE = 4;
 
var combinedFlag = FLAGONE | FLAGTHREE;
 
trace("FLAGONE: " + (combinedFlag & FLAGONE)); // traces "1"
trace("FLAGTWO: " + (combinedFlag & FLAGTWO)); // traces "0"
trace("FLAGTHREE: " + (combinedFlag & FLAGTHREE)); // traces "4" 
 

Everything that doesn't result in 0 means the flag is in it. Remember for example 16 only means the flag with the bit 5 (from the right) set. This can become cumbersome though when you have a lot of flags or when you add or remove flags. You want a dynamic way that lists all the flags in a combined flag. Here is one way:

// create the flags and put them in an array we'll
// use to run through for tracing separate flags
var flags:Array = new Array();
var FLAGONE = 1; flags.push(FLAGONE);
var FLAGTWO = 2; flags.push(FLAGTWO);
var FLAGTHREE = 4; flags.push(FLAGTHREE);
 
// return a list of flags that are in the combined flag
function listFlags(combinedFlag:Number): Array {
        var result:Array = new Array();
        for (var flag in flags) {
                // check if flag is in the combined flag
                if (combinedFlag & flags[flag]) {
                        result.push(flags[flag]);
                }
        }
        return result;
}
 
var combinedFlag = FLAGONE | FLAGTHREE;
trace(listFlags(combinedFlag)); // traces "4, 1" 
 

There's one problem though. This method returns only the values of those individual flags, not their names. If you want their names as well (or some other description), create the constants another way:

// create the flags and put them in an array including descriptions
// we'll use to run through for tracing separate flags
var flags:Array = new Array();
var FLAGONE = 1; flags[FLAGONE] = [FLAGONE, "Flag 1 for some purpose"];
var FLAGTWO = 2; flags[FLAGTWO] = [FLAGTWO, "Flag 2"];
var FLAGTHREE = 4; flags[FLAGTHREE] = [FLAGTHREE, "Flag 3 yay"];
 
// return a list of flags that are in the combined flag
function listFlags(combinedFlag:Number): Array {
        var result:Array = new Array();
        for (var flag in flags) {
                // check if flag is in the combined flag
                if (combinedFlag & flags[flag][0]) {
                    // add the flag's description
                    result.push(flags[flag][1]);
                }
        }
        return result;
}
 
var combinedFlag = FLAGONE | FLAGTHREE;
trace(listFlags(combinedFlag));
// traces:
// "Flag 1 for some purpose"
// "Flag 3 yay" 
 

[Codemonkey]

&nbsp
When you add new flags, move them around or change them a lot, it can be an annoyance to have to update all the flag values each time, making sure they are unique and doubled each time.

To make things a little bit easier, you can use the bitshift operator. The bitshift operator 'knows' you want to store a value as a bit representation, like all the flags we've been defining. Here's an example:

var OLD_ONE = 1;
var OLD_TWO = 2;
var OLD_THREE = 4;
var OLD_FOUR = 8;
 
var NEW_ONE     = 1 << 0; // shift bit 0 left
var NEW_TWO     = 1 << 1; // shift bit 1 left
var NEW_THREE   = 1 << 2; // shift bit 2 left
var NEW_FOUR    = 1 << 3; // shift bit 3 left
 
trace(OLD_ONE == NEW_ONE); // "true"
trace(OLD_TWO == NEW_TWO); // "true"
trace(OLD_THREE == NEW_THREE); // "true"
trace(OLD_FOUR == NEW_FOUR); // "true" 
 

Here's a more practical way:

var shifts:Number = 0;
 
var NEW_ONE     = 1 << shifts++; // 1
var NEW_TWO     = 1 << shifts++; // 2
var NEW_THREE   = 1 << shifts++; // 4
var NEW_FOUR    = 1 << shifts++; // 8 
 

Now you can move the flags around without having to worry about their values.

[Nutrox]

 
Shared Libraries can be summed up in four words: pain in the ass. They can still be used with AS3 but why bother with them when there is an easier way to pull library assets from SWF files!

Let's say that you have a SWF and in that SWF file's library is a sound file linked to the first frame of the movie with the class name "MySound". The following code demonstrates how to load that SWF file into another SWF file, grab the sound from the library, and then play the sound. Woohoo!

import flash.events.Event;
import flash.net.URLRequest;
import flash.display.Loader;
import flash.media.Sound;
 
var req:URLRequest = new URLRequest("library.swf");
var loader:Loader = new Loader();
loader.contentLoaderInfo.addEventListener(Event.COMPLETE, onLibraryLoaded);
loader.load(req);
 
var mySound:Sound;
 
function onLibraryLoaded(e:Event):void
{
    var cls:Class = Class(loader.contentLoaderInfo.applicationDomain.getDefinition("MySound"));
    mySound = new cls();
    mySound.play();
} 

This method can probably be used for most of the library assets you can store in a SWF file. I think you might even be able to use this with fonts but I haven't tried that yet.

Have fun!

[Codemonkey]

 
If you use the EventDispatcher to allow listeners to listen for events on your object, your object gets a list for these listeners and a bunch of functions like dispatchEvent etc. To access this array of listeners, use the property "__q_" on your object. This is the name of the array the EventDispatcher adds to your object:

Setting up the event dispatching object and a listener:

import mx.events.EventDispatcher;
var eventsource:Object = new Object();
EventDispatcher.initialize(eventsource);
 
var listener = new Object();
listener.foo = function (eventObj:Object) {
        trace(eventObj.message); // "I like apple pie!"
}
 
eventsource.addEventListener("foo", listener);
eventsource.dispatchEvent({type:"foo", target:this, message:"I like apple pie!"}); 

Get access to the array of listeners:

trace(eventsource["__q_" + "foo"] instanceof Array); // traces "true"
trace(eventsource["__q_" + "foo"].length); // traces "1" 
 

[Codemonkey]

 
If for some reason you think "Why is this or that tracing undefined??" or "Why isn't my function executing omg!". Then for the love of God, think of Delegates!! Search Ultrashock on the word "scope" and "Delegate" and don't ask us again please

Classic example:

class MyXMLParser {
    var books:Array = new Array();
 
    function doIt() {
        var xml:XML = new XML();
        xml.onLoad = parseXML;
        xml.load("books.xml");
    }
 
    function parseXML(success:Boolean) {
        // parse xml stuff
        books.push(book_from_xml); // BUZZ, can't find books!
    }
} 

Books couldn't be found, because when the xml object calls parseXML, the scope is in the xml object, not MyXMLParser. And so you can't access books because it isn't in the xml object.

Fix this with a Delegate:

import mx.utils.Delegate;
 
class MyXMLParser {
    var books:Array = new Array();
 
    function doIt() {
        var xml:XML = new XML();
        xml.onLoad = Delegate.create(this, parseXML);
        xml.load("books.xml");
    }
 
    function parseXML(success:Boolean) {
        // parse xml stuff
        books.push(book_from_xml); // DING, can find books!
    }
} 

[Nutrox]

 
Following on from Codemonkey's look at the Delegate class, I actually use my own delegate-like class for fixing scope. This version allows you to pass custom arguments to the target method without overwriting any arguments that Flash might spit out, the standard Delegate class will overwrite those arguments.

Here is the AS2 class:

class cs.utils.Scope
{
    public static function rewire(scope:Object, func:Function):Function
    {
        var args:Array = [];
 
        if (arguments.length > 2)
        {
            args = arguments.splice(2, arguments.length - 2);
        }
        return function()
        {
            return func.apply(scope, args.concat(arguments));
        }
    }
} 

A good example of how to use the class would be with the XML.onLoad event:

import cs.utils.Scope;
 
var xml:XML = new XML();
xml.ignoreWhite = true;
xml.onLoad = Scope.rewire(this, xmlLoadHandler, "Hello!", xml);
 
xml.load("file.xml");
 
function xmlLoadHandler(word:String, xmlFile:XML, success:Boolean):Void
{
    if (!success)
    {
        // D'oh!
    }
    else
    {
        trace(this);           // _level0
        trace(word);           // output: Hello!
        trace(xmlFile == xml); // output: true
        trace(this == xml);    // output: false
    }
} 

As you can see the scope of the xmlLoadHandler will be _level0 instead of the XML object. Your custom arguments will be passed to method before any of the default ones that Flash might send (i.e. success).

[Nutrox]

 
You can use the bitwise right-shift operator to floor a number instead of using Math.floor(). Normally Math.floor() is absolutely fine to use, but if you are concerned about CPU cycles then this alternative will come in handy because it is a lot quicker than Math.floor().

Here is an example using Math.floor()...

var num:Number = 123.456;
num = Math.floor(num);
 
trace( num ); // output: 123 
 

...and here is the same thing, but this time the bitwise right-shift operator is used...

var num:Number = 123.456;
num >>= 0; // num >>= zero
 
trace( num ); // output: 123 
 

[Nutrox]

 
Here is a little utility function that you can use to round numbers to a certain decimal point.

It is very easy to use so I'll just drop some example code here...

function roundTo(value:Number, points:Number):Number
{
    if (points == null || points < 1)
    {
        return value >> 0;
    }
    var delta:Number = Math.pow(10, points);
    
    return (value * delta >> 0) / delta;
}
 
//
 
var num:Number = 100.24680;
 
trace( roundTo(num) );    // output: 100
trace( roundTo(num, 0) ); // output: 100
trace( roundTo(num, 1) ); // output: 100.2
trace( roundTo(num, 2) ); // output: 100.24
trace( roundTo(num, 3) ); // output: 100.246
trace( roundTo(num, 4) ); // output: 100.2468
trace( roundTo(num, 5) ); // output: 100.23680 
 

[Nutrox]

 
Array mapping can come in very useful sometimes. What array mapping basically does is pass each array value to a function, and that function can then either alter the array value or return a result based on the array value.

I have included a prototype function and a standard function here just in case you prefer a particular flava.

You setup the Array prototype method like this:

Array.prototype.map = function(callback)
{
    var a = [];
    var n = this.length;
    while (n--)
    {
        a[n] = callback(this, n, this[n]);
    }
    return a;
} 

Prototype Example 1
This example checks to see which values in the myNumbers array are greater than 3. The results (in this example true or false) will be returned in an array.

var myNumbers = [1, 2, 3, 4, 5, 6];
var results   = myNumbers.map(checkNumbers);
 
trace( results ); // false, false, false, true, true, true
 
//
 
function checkNumbers(array, index, value)
{
    // Check if the value is greater than 3.
    return value > 3;
} 

Prototype Example 2
This example will prefix each value in the myNames array with "Name: ".

var myNames = ["Andy", "Bob", "Charlie", "Dood"];
var newNames = myNames.map(changeNames);
 
trace( newNames ); // Name: Andy, Name: Bob, Name: Charlie, Name: Dood
 
//
 
function changeNames(array, index, value)
{
    return "Name: " + value;
} 

Better Example 1
We have left the world of prototypes now. This is the same example as Prototype Example 1 but instead of using a prototype a standalone function is used for the array mapping.

function mapArray(array:Array, callback:Function):Array
{
    var a:Array = [];
    var n:Number = array.length;
    while (n--)
    {
        a[n] = callback(array, n, array[n]);
    }
    return a;
}
 
//
 
var myNumbers:Array = [1, 2, 3, 4, 5, 6];
var results:Array   = mapArray(myNumbers, checkNumbers);
 
trace( results ); // false, false, false, true, true, true
 
//
 
function checkNumbers(array:Array, index:Number, value):Array
{
    return value > 3;
} 

PS: Array mapping is built-in to the AS3 Array class, so these examples are only useful for AS1 / AS2.

[Codemonkey]

 
You can't dynamically call functions with eval() like in Javascript or PHP unless you create your own parser for it, as well as for assignments etc. Flash can only locate identifiers for you with eval and that isn't necessary anymore these days.

If you want a quick way to call certain functions using a string, here's one way to do that (in AS2 at least):

// some values and a user function we'll call
var monkeys:String = "monkeys!";
var apes:String = "apes!";
 
function myFunc(str1:String, str2:String) {
    trace(str1 + " and " + str2);
}
 
// locate a function and apply the arguments to it
function parseFunction(s:String) {
    var fname:String = s.split("(")[0];
    var parameters:String = s.split(")")[0].substr(fname.length + 1);
    var paramlist:Array = parameters.split(", ");
    
    // get the results of each argument
    for (i in paramlist) {
        paramlist[i] = eval(paramlist[i]);
    }
    // call the function with the specified arguments
    var func:Function = eval(fname);
    func.apply(this, paramlist);
}
 
// try to call user function, and a system function
parseFunction("myFunc(monkeys, apes);");
monkeys = "three little monkeys";
parseFunction("trace(monkeys);"); 

You could expand it to parse expressions as well and execute several commands by splitting the string with ';'.

[Nutrox]

 
In a nutshell: Array rotation simply means shifting the array values to new positions while keeping their relative order.

Here is a quick example followed by the prototype version:

function rotateArray(arr:Array, amount:Number):Void
{
    var delta:Number = amount * -1;
    if (amount < 0)
    {
        arr.splice(amount, null, arr.splice(0, delta));
    }
    else if (amount > 0)
    {
        arr.splice(0, null, arr.splice(delta, amount));
    }
}
 
//
 
var numbers:Array = [1,2,3,4,5];
 
rotateArray(numbers, -1);
trace( numbers ); // 2,3,4,5,1
 
rotateArray(numbers, 1);
trace( numbers ); // 1,2,3,4,5
 
rotateArray(numbers, 3);
trace( numbers ); // 3,4,5,1,2 
 

Array.prototype.rotate = function(amount)
{
    var delta = amount * -1;
    if (amount < 0)
    {
        this.splice(amount, null, this.splice(0, delta));
    }
    else if (amount > 0)
    {
        this.splice(0, null, this.splice(delta, amount));
    }
}
 
//
 
var numbers = [1,2,3,4,5];
 
numbers.rotate(-1);
trace( numbers ); // 2,3,4,5,1
 
numbers.rotate(1);
trace( numbers ); // 1,2,3,4,5
 
numbers.rotate(3);
trace( numbers ); // 3,4,5,1,2 
 

[Nutrox]

 
Using the bit-shifting techniques that Codemonkey has covered allows you to quickly and easily manipulate colour values.

This first example demostrates how you can get the individual colour values from a RGB colour value:

var colour:Number = 0xFA802A;
 
var red:Number   = colour >> 16 & 255;
var green:Number = colour >> 8 & 255;
var blue:Number  = colour & 255;
 
trace( red   ); // 250
trace( green ); // 128
trace( blue  ); // 42
 
trace( red.toString(16)   ); // fa
trace( green.toString(16) ); // 80
trace( blue.toString(16)  ); // 2a 
 

If you want to construct a RGB colour value from red, green, and blue values then you can do this:

var red:Number   = 0x80;
var green:Number = 0xFF;
var blue:Number  = 0xCA;
 
var colour:Number = 0;
 
colour |= red   << 16;