Flash
 ActionScript

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.

[as]myMovieClip.__proto__ = new MyClass();[/as]
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.

[as]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;
}

}[/as]

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:

[as]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] = unescape(_level0[s]);
  }
  else {
    o[n] = Number(_level0[s]);
  }
  }
  else {
  if (isNaN(_level0[s])) {
    o[n] = unescape(_level0[s]);
  }
  else {
    o[n] = Number(_level0[s]);
  }
  }
  }
}
return o;
}[/as]
Here are a few examples of use. Note that each flashVar name is prefixed with fv_

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.

[as]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 == func) {
  delete frameListeners.splice(i, 1);
  break;
  }
}
if (!frameListeners.length) {
  this.onEnterFrame = null;
}
}

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:

[as]String.prototype.reverse = function() {
      var a = this.split(”“);
      a.reverse();
      return a.join(”“);
};[/as]
Now that the new function has been added you will be able to reverse any of your strings:

[as]var myText = “Hello Ultrashock”;
trace(myText); // output: Hello Ultrashock

myText = myText.reverse();
trace(myText);// output: kcohsartlU olleH[/as]
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:

[as]Array.prototype.shuffle = function() {
var a = [].concat(this);
var i = a.length;
var n;
while (i—) {
  n = Math.floor(Math.random() * a.length);
  this = a.splice(n, 1);
} 
}[/as]
Now you can shuffle any array in your movie:

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:

[as]
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++;
}
}
[/as]

To use it:

[as]
import util.FPS;

// create FPS meter and update every 500ms
var fps:FPS = new FPS(500);
fps.onUpdate = function(fps:Number) {
trace(fps);
}
[/as]
Don’t set the interval too low though (min. 250ms) or the measurements become unreliable.

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

[as]
import flash.geom.Point;

function transCoord(coord:Point, from:MovieClip, to:MovieClip):Void {
  from.localToGlobal(coord);
  to.globalToLocal(coord);
}
[/as]
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.

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:

[as]
// 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 == item) {
  return Number(i);
  }
  }
  return -1;
}
[/as]
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:

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:

[as]
class MyUtil {
}
[/as]
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.

[as]
class MyUtil {
public static function MyUtilFunction(params_here):Number {
// do stuff with params and return result
}
}
[/as]
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:

[as]
class MyUtil {
private function MyUtil() {}
}
[/as]
Here’s an example of a complete util class:

[as]
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 {
      [..]
}
}
[/as]
Usage:

[as]
var names:Array = new Array(“Bob”, “Shirley”, “Pete”);
trace(ArrayUtils.arrayRemove(array, “Bob”)); // traces “true”
trace(ArrayUtils.arrayRemove(array, “Bill”)); // traces “false”
[/as]