A quick, but necessary reminder: I am a Flash designer attempting to learn more about ActionScript development so please follow at your own risk and if you see an error please leave a comment.

We’ll begin with an ActionScript 2.0 version since I need a little refresher.  Revisiting AS2 makes me appreciate AS3 that much more.  Here’s a sample usage of the particle system:

(this performance test was inspired by the GreenSock Performance Tests)

These sites are good reads and helped point me in the right direction: Particle System API and “Particle Systems” by Allen Martin.  The library is simple and consists of only 2 classes: a Particle class and an Emitter class.  The Particle class will represent a single particle that is instantiated by the Emitter class.

The Particle Class

//AS2///////////////////////////////////////////////////////////////////////////
//
//  Emitter
//
//  Copyright (c) 2009 Jason Woan. All rights reserved.
//
//  Do what you want with the code.  Credit is nice but not necessary.  Use at
//  your own risk and discretion.  I won't be held responsible if your site
//  blows up.  Enjoy!
//
////////////////////////////////////////////////////////////////////////////////

/**
 *	This class is the blueprint to a single particle maintaining its inherent
 *	properties and performing position calculations.  Use as a MovieClip's
 *	linkage class.
 *
 *	@version 0.1.0
 *	@langversion ActionScript 2.0
 *	@playerversion Flash 8.0
 *
 *	@author Jason_Woan
 *	@since  2009-05-14
 */
dynamic class com.jasonwoan.speck.Particle extends MovieClip {

	//--------------------------------------
	//  PUBLIC VARIABLES
	//--------------------------------------

	public var xVelocity:Number = 1;
	public var yVelocity:Number = 1;
	public var xAccel:Number = 0;
	public var yAccel:Number = 0;
	//public var rotationalVelocity:Number = 0;
	//public var mass:Number = 1;
	public var age:Number = 0;
	public var life:Number = 10;
	public var dead:Boolean = false;
	public var direction:Number = 45;
	public var speed:Number = 1;
	public var fade:Boolean = false;
	public var scale:Number = 100;
	public var shrink:Boolean = false;
	public var xMinBound:Number;
	public var xMaxBound:Number;
	public var yMinBound:Number;
	public var yMaxBound:Number;
	public var restitution:Number;

	//--------------------------------------
	//  PRIVATE & PROTECTED VARIABLES
	//--------------------------------------

	private var _xPrevious:Number;
	private var _yPrevious:Number;
	private var _scaleStart:Number;

	//--------------------------------------
	//  CONSTRUCTOR
	//--------------------------------------
	/**
	 *	@constructor
	 */
	public function Particle() {
		// calculate directional velocity
		var radDirection:Number = this.direction * Math.PI / 180;
		xVelocity = this.speed * Math.cos(radDirection);
		yVelocity = this.speed * Math.sin(radDirection);
		this._xscale = this._yscale = this.scale;
	}

	//--------------------------------------
	//  PUBLIC METHODS
	//--------------------------------------

	public function update():Void
	{
		if (!dead) {
			// save previous position
			this._xPrevious = this._x;
			this._yPrevious = this._y;

			// check bounds
			if (this.xMinBound != undefined) {
				if (this._x + this.xVelocity < this.xMinBound) {
					this.xVelocity = -1 * this.restitution;
				}
			}
			if (this.xMaxBound != undefined) {
				if (this._x + this.xVelocity > this.xMaxBound) {
					this.xVelocity = -1 * this.restitution;
				}
			}
			if (this.yMinBound != undefined) {
				if (this._y + this.yVelocity < this.yMinBound) {
					this.yVelocity *= -1 * this.restitution;
				}
			}
			if (this.yMaxBound != undefined) {
				if (this._y + this.yVelocity > this.yMaxBound) {
					this.yVelocity *= -1 * this.restitution;
				}
			}

			// update position
			this._x += this.xVelocity;
			this._y += this.yVelocity;

			// update velocity
			this.xVelocity += this.xAccel;
			this.yVelocity += this.yAccel;

			this.age++;

			// particle shape and alpha dynamics
			if (this.fade) {
				this._alpha = 100 - Math.round(this.age / this.life * 100);
			}

			if (shrink) {
				this._xscale = this._yscale = this.scale - Math.round(this.age / this.life * scale);
			}

			// check for death
			if (this.age == this.life) {
				this.dead = true;
				this._visible = false;
			}
		}
	}

	public function revive():Void
	{
		if (this.dead) {
			this.dead = false;
			this._visible = true;
			this.age = 0;
			// reset velocities
			var radDirection:Number = this.direction * Math.PI / 180;
			this.xVelocity = this.speed * Math.cos(radDirection);
			this.yVelocity = this.speed * Math.sin(radDirection);
		}
	}
}

The Emitter Class

//AS2///////////////////////////////////////////////////////////////////////////
//
//  Emitter
//
//  Copyright (c) 2009 Jason Woan. All rights reserved.
//
//  Do what you want with the code.  Credit is nice but not necessary.  Use at
//  your own risk and discretion.  I won't be held responsible if your site
//  blows up.  Enjoy!
//
////////////////////////////////////////////////////////////////////////////////

import mx.utils.Delegate;

import com.tbwachiat.speck.Particle;

/**
 *	The Emitter manages the creation of particles.
 *
 *	@version 0.1.0
 *	@langversion ActionScript 2.0
 *	@playerversion Flash 8.0
 *
 *	@author Jason_Woan
 *	@since  2009-05-14
 */
class com.jasonwoan.speck.Emitter {

	//--------------------------------------
	//  PRIVATE & PROTECTED VARIABLES
	//--------------------------------------

	private var _gravity:Number = 0;

	// number of particles per step
	private var _birthRate:Number = 3;

	// the life of each particle in seconds
	private var _life:Number = 100;

	private var _scale:Number = 100;
	private var _scaleMin:Number;
	private var _scaleMax:Number;
	private var _speed:Number = 1;
	private var _direction:Number = 45;
	private var _randomDirection:Boolean = false;

	private var _xAccel:Number = 0;
	private var _yAccel:Number = 0;

	private var _xMin:Number = 0;
	private var _xMax:Number = 0;
	private var _yMin:Number = 0;
	private var _yMax:Number = 0;

	private var _xMinBound:Number;
	private var _xMaxBound:Number;
	private var _yMinBound:Number;
	private var _yMaxBound:Number;
	private var _restitution:Number = 1;

	private var _fade:Boolean = false;
	private var _shrink:Boolean = false;

	private var _emitter:MovieClip;
	private var _particleID:String;
	private var _particles:Array;

	private var _oldestIndex:Number = 0;

	//--------------------------------------
	//  CONSTRUCTOR
	//--------------------------------------
	/**
	 *	@constructor
	 */
	public function Emitter(pEmitter:MovieClip, pParticleID:String, pParameters:Object) {
		_emitter = pEmitter;
		_particleID = pParticleID;
		_particles = new Array();

		// check parameter object
		for (var prop in pParameters) {
			switch (prop) {
				// the life of a particle in frames
				// the particle will be recycled if dead
				case "life" :
				if (pParameters[prop] > 0) _life = pParameters[prop];
				break;

				// the number of particles generated per update on enter frame
				case "birthRate" :
				if (pParameters[prop] > 0) _birthRate = pParameters[prop];
				break;

				// a positive acceleration of a particle in the y-direction
				case "gravity" :
				_gravity = pParameters[prop];
				break;

				// the initial x and y scale of a particle
				case "scale" :
				_scale = pParameters[prop];
				break;

				// the minimum initial x and y scale of a particle
				// use in conjuction with scaleMax
				case "scaleMin" :
				_scaleMin = pParameters[prop];
				break;

				// the maximum initial x and y scale of a particle
				// use in conjuction with scaleMin
				case "scaleMax" :
				_scaleMax = pParameters[prop];
				break;

				// the distance traveled by the particle per enter frame
				case "speed" :
				_speed = pParameters[prop];
				break;

				// acceleration of the particle in the x-direction
				case "xAccel" :
				_xAccel = pParameters[prop];
				break;

				// acceleration of the particle in the y-direction
				case "yAccel" :
				_yAccel = pParameters[prop];
				break;

				// the minimum initial x position to create a particle
				case "xMin" :
				_xMin = pParameters[prop];
				break;

				// the maximum initial x position to create a particle
				case "xMax" :
				_xMax = pParameters[prop];
				break;

				// the minimum initial y position to create a particle
				case "yMin" :
				_yMin = pParameters[prop];
				break;

				// the maximum initial y position to create a particle
				case "yMax" :
				_yMax = pParameters[prop];
				break;

				// the left "wall" of the emitter
				case "xMinBound" :
				_xMinBound = pParameters[prop];
				break;

				// the right "wall" of the emitter
				case "xMaxBound" :
				_xMaxBound = pParameters[prop];
				break;

				// the "ceiling" of the emitter
				case "yMinBound" :
				_yMinBound = pParameters[prop];
				break;

				// the "floor" of the emitter
				case "yMaxBound" :
				_yMaxBound = pParameters[prop];
				break;

				// if true, the particle will fade away in proportion
				// to the particles age and life
				case "fade" :
				_fade = pParameters[prop];
				break;

				// if true, the particle will shrink away in proportion
				// to the particles age and life
				case "shrink" :
				_shrink = pParameters[prop];
				break;

				// the amount of velocity retained when a particle
				// hits a wall, ceiling or floor
				case "restitution" :
				_restitution = pParameters[prop];
				break;

				// the initial direction of a particle in degrees or
				// "random" string
				case "direction" :
				// check for random string
				if (pParameters[prop] == "random") {
					_randomDirection = true;
				} else {
					if (typeof(pParameters[prop]) == "number") _direction = pParameters[prop];
				}
				break;
			}
		}
	}

	//--------------------------------------
	//  GET / SET
	//--------------------------------------

	/**
	 *	@private
	 */
	public function get numParticles():Number
	{
		return _particles.length;
	}

	//--------------------------------------
	//  PUBLIC METHODS
	//--------------------------------------

	/**
	 *	Starts the emitter.
	 */
	public function start():Void
	{
		_emitter.onEnterFrame = Delegate.create(this, update);
	}

	/**
	 *	Stops the emitter.
	 */
	public function stop():Void
	{
		delete _emitter.onEnterFrame;
	}

	//--------------------------------------
	//  PRIVATE & PROTECTED INSTANCE METHODS
	//--------------------------------------

	/**
	 *	Step update method.
	 */
	private function update():Void
	{
		// update all particles
		var i:Number = _particles.length;
		while (i--) {
			_particles[i].update();
		}

		// create particles specified in birth rate

		var particle:MovieClip;
		var d:Number;
		var startX:Number;
		var startY:Number;
		var scale:Number;
		i = _birthRate;
		while (i--) {
			d = (_randomDirection) ? Math.round(Math.random() * 360) : _direction;
			startX = _xMin + Math.round(Math.random() * (_xMax - _xMin));
			startY = _yMin + Math.round(Math.random() * (_yMax - _yMin));

			if (_scaleMin != undefined && _scaleMax != undefined) {
				scale = _scaleMin + Math.round(Math.random() * (_scaleMax - _scaleMin));
			} else {
				scale = _scale;
			}

			// resuse dead particles first
			if (_particles[_oldestIndex].dead) {
				particle = _particles[_oldestIndex];
				particle.revive();
				particle._x = 0;
				particle._y = 0;
				if (_oldestIndex + 1 < _particles.length) {
					_oldestIndex++;
				} else {
					_oldestIndex = 0;
				}
			} else {
				// create a new particle
				particle = _emitter.attachMovie(_particleID, _particleID + _particles.length, _emitter.getNextHighestDepth(), {direction:d, speed:_speed, scale:scale});
				_particles.push(particle);
			}

			// set particle properties
			particle.life = _life;
			particle._x = startX;
			particle._y = startY;
			particle.xAccel = _xAccel;
			particle.yAccel = _yAccel + _gravity;
			particle.fade = _fade;
			particle.shrink = _shrink;

			particle.xMinBound = _xMinBound;
			particle.xMaxBound = _xMaxBound;
			particle.yMinBound = _yMinBound;
			particle.yMaxBound = _yMaxBound;
			particle.restitution = _restitution;
		}
	}
}

Usage

First add the particle system package to the class path in the Publish Settings or ActionScript 2.0 preferences. Create a particle MovieClip in Flash and point its linkage class to the Particle class location.

Create an empty MovieClip that will serve as the particle container where all particles instances will be created. Create an instance of the Emitter and assign the empty container MovieClip as the first argument and the linkage identifier of the particle symbol as the second argument. Don’t forget to import the particle system package (coined speck). Use the start and stop methods of the Emitter object to control the system.

import com.jasonwoan.speck.*;

var e:Emitter = new Emitter(emitterMC, "FireParticle");
e.start();

This is the most basic usage of this particle system. To customize the default emitter, you’ll want to add an object of parameters as a third argument when instantiating an Emitter. Please refer to the comments in the Emitter class for a description of valid parameters and their effects. Try messing around with the sample usage at the beginning of the post.

Finally

This is by no means a robust particle system. Ideally, I’d like to create a ParticleSystem object that would manage any number of Emitters and apply global forces like gravity and surface friction. I would also add a cue parameter so an Emitter can be tweened. I’ll save most of those updates for the AS3 version due to performance issues with AS2. This particle system library is lightweight and will probably serve well for simple particle effects.

I came across the following “gotcha” during development:

In ActionScript 2.0, an array used as an instance property should be initialized inside the constructor or any subsequent method and NOT when declaring the instance variable. When you initialize and declare and array instance property the value seems to be treated globally and multiple instances of that object will share the value even though it is access modifier is set to private. For example:

Bad

class MyClass{
	private var myArray:Array = [];

	public function MyClass() {

	}
}

Good

class MyClass{
	private var myArray;

	public function MyClass() {
		myArray = [];
	}
}

I’ll post the AS3 version as soon as I finish it. Thanks for reading and comments/questions/suggestions/recommendations are appreciated.

Download Source

TweetDeck

Get it Here

Anyone who tweets is probably familiar with this app.  It’s simply an amazing way to create and manage tweets.

ShareFire

Get it Here

Great XML reader/manager.  Entries can be viewed as HTML using the in-built browser.  Import/export functionality keeps you somewhat synced.

Doc? Local Live Docs

Get it Here

I constantly use the Actionscript 3.0 Language and Component Reference and this app allows me to keep it readily available.  There are also plugins for Eclipse and Flash that allow you to easily access the app.

This ActionScript 3.0 class is inspired by Mathieu Badimon’s text effect on his Lab site.   The class extends TextField and utilizes a randomText property to trigger the randomized text effect.

For example,

var random_tf:RandomTextField = new RandomTextField;
random_tf.randomText = "Hello WTFlash!";

There are some optional parameters you can set which allow you to control the number of random characters to display per character of text, the placeholder string, and the delay interval between character swaps.

var random_tf:RandomTextField = new RandomTextField(4, "*", 1000);

or

var random_tf:RandomTextField = new RandomTextField();
random_tf.numberRandomCharacters = 4;
random_tf.placeholder = "*";
random_tf.swapDelay = 1000;

Here is the class (NOTE: I’m trying out MonsterDebugger in my workflow):

package com.jasonwoan.text {
/**
*	[RandomTextField]
*
*	@class			RandomTextField
*	@author    Jason Woan
*	@version		1.0.0
*	@date			Feb 7, 2009
*	@langversion	ActionScript 3.0
*	@playerversion	Flash Player 9
*
*	@history 1.0.0 (Feb 7, 2009) Created initial version of RandomTextField for AS3.
*/

//--------------------------------------------------
// IMPORT STATEMENTS
//--------------------------------------------------

import nl.demonsters.debugger.MonsterDebugger;

import flash.events.*;
import flash.text.*;
import flash.utils.Timer;

public class RandomTextField extends TextField {

//--------------------------------------------------
// PRIVATE STATIC PROPERTIES
//--------------------------------------------------

/**
*	The fully qualifed class name and path. This can be accessed from the class but the value
* 	can also be retrieved from the instance using the getter fullyQualifedClassPath
*/
private static const FULLY_QUALIFIED_CLASS_PATH: String = "com.jasonwoan.text.RandomTextField";

//--------------------------------------------------
// PRIVATE PROPERTIES
//--------------------------------------------------
/**
*	A reference to this instance.
*/
private var _instance:RandomTextField;

/**
* 	The random text string
*/
private var _random_text:String;

/**
* 	The number of randomized characters to display per character
*/
private var _num_random:uint = 2;

/**
* 	A timer used to display the randomized characters
*/
private var _timer:Timer;

/**
* 	The placeholder character
*/
private var _placeholder:String = "+";

/**
* 	A string of characters
*/
private var _characters:String = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYX01234567890.!@#$%&";

/**
* 	An array of characters.
*/
private var _char_arr:Array;

/**
* 	The current index in the message
*/
private var _text_index:uint;

/**
* 	The current random index
*/
private var _random_index:uint;

/**
* 	Timer delay
*/
private var _timer_delay:Number = 34;

//--------------------------------------------------
// CONSTRUCTOR
//--------------------------------------------------
/**
*	Constructor
*/
public function RandomTextField(p_num_random:uint = 2, p_placeholder:String = "+", p_swap_delay:Number = 34)
{
MonsterDebugger.trace(this, "[" + fullyQualifiedClassPath + "] constructor:");

super();

_instance = this;
_num_random = p_num_random;
_placeholder = p_placeholder;
_timer_delay = p_swap_delay;

init();
}

//--------------------------------------------------
// GETTERS / SETTERS
//--------------------------------------------------
/**
*	Returns the fully qualified class path which includes the class package and class name as a string
*
*	@return	-	String representing the full class path.
*						For example: com.jasonwoan.text.RandomTextField
*/

public function get fullyQualifiedClassPath(): String
{
return  RandomTextField.FULLY_QUALIFIED_CLASS_PATH;
}

/**
*	Returns the random text string.
*	@return
*/
public function get randomText():String
{
return _instance._random_text;
}

/**
*	Sets the random text string
*	@param
*	@return	void
*/
public function set randomText(p_param:String):void
{
MonsterDebugger.trace(this,"[" + fullyQualifiedClassPath + ".randomText]");

_random_text = p_param;
_text_index = 0;
_random_index = 0;

// start the randomization typing
_timer.stop();
_timer.reset();
_timer.start();
}

/**
*	Returns the delay between character swaps.
*	@return
*/
public function get swapDelay():Number
{
return _timer_delay;
}

/**
*	Sets the delay between character swaps.
*	@param
*	@return	void
*/
public function set swapDelay(p_param:Number):void
{
_timer_delay = p_param;
_timer.delay = _timer_delay;
}

/**
*	Returns the placeholder character.
*	@return
*/
public function get placeholder():String
{
return _placeholder;
}

/**
*	Sets the placeholder character.
*	@param
*	@return	void
*/
public function set placeholder(p_param:String):void
{
_placeholder = p_param;
}

/**
*	Returns the number of random characters to swap before the correct
*	character is displayed.
*	@return
*/
public function get numberRandomCharacters():uint
{
return _num_random;
}

/**
*	Sets the number of random characters to swap before the correct
*	character is displayed.
*	@param
*	@return	void
*/
public function set numberRandomCharacters(p_param:uint):void
{
_num_random = p_param;
}

//--------------------------------------------------
// EVENT HANDLERS
//--------------------------------------------------

/**
*	Invoked when the timer event is triggered.
*	@param	p_event	()
*	@return	void
*/
private function onTimer(p_event:TimerEvent):void
{
cycleCharacter();
}

//--------------------------------------------------
// PUBLIC METHODS
//--------------------------------------------------

/**
*	Destroys this object for garbage collection.
*
*	@return	void
*/

public function destroy():void
{
MonsterDebugger.trace(this,"[" + fullyQualifiedClassPath + ".destroy]");

_instance = null;
}

//--------------------------------------------------
// PRIVATE METHODS
//--------------------------------------------------

/**
*	Initializes class instance.
*
*	@return	void
*/

private function init():void
{
MonsterDebugger.trace(this,"[" + fullyQualifiedClassPath + ".init]");

_char_arr = _characters.split("");
_timer = new Timer(_timer_delay);
_timer.addEventListener(TimerEvent.TIMER, onTimer);
}

/**
*	Cycles through each character of the alphabet to find a matching character.
*	@return	void
*/
private function cycleCharacter():void
{
// check to see if the message index is less than the message length
if (_text_index == _random_text.length) {
_timer.stop();
return;
}

var s:String = "";
var random_char:String;

// check for next
if (_random_index == _num_random) {
// set correct character
random_char = _random_text.charAt(_text_index);
// move on to next character
_random_index = 0;
_text_index++;
} else {
random_char = _char_arr[Math.floor(Math.random() * _char_arr.length)];
_random_index++;
}

// build string
for (var i:uint = 0; i < _random_text.length; i++) {
if (i == _text_index) {
// add random character;
s += random_char;
} else
if (i > _text_index) {
// add placeholder;
s += _placeholder;
} else
if (i < _text_index) {
// add correct character
s += _random_text.charAt(i);
}
}

_instance.text = s;
}
}
}

Enjoy!

…and follow the timeline structure as follows (the “hit_mc” layer allows a hit sprite with an instance name “hit_mc” to be used as the button’s hit area):

It’s a good starting point for almost any button situation. The flexibility of the timeline structure allows for complex animations and it can be extended to create more specific types of buttons, i.e. ToggleButton.

[cc lang="actionscript" tab_size="2" lines="100"]
package com.jasonwoan.display {
/**
* [BasicButton]
*
* @class BasicButton
* @author Jason Woan
* @version 1.0.0
* @date March 3, 2008
* @langversion ActionScript 3.0
* @playerversion Flash Player 9
*
* @history 1.0.0 (March 3, 2008) Created initial version of BasicButton for AS3.
*/

//————————————————–
// IMPORT STATEMENTS
//————————————————–

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

public class BasicButton extends MovieClip {

//————————————————–
// PUBLIC STATIC PROPERTIES
//————————————————–
/**
* The fully qualifed class name and path. This can be instanceed from the class but the value
* can also be retrieved from the instance using the getter fullyQualifedClassPath
*/
public static var FULLY_QUALIFIED_CLASS_PATH:String = “com.jasonwoan.display.BasicButton”;

//————————————————–
// PRIVATE PROPERTIES
//————————————————–
/**
* A reference to this instance.
*/
protected var _instance:BasicButton;

/**
* A boolean flag indicating whether the button is on.
*/
private var _is_on:Boolean = true;

/**
* An integer id representing this button
*/
private var _id:uint;

/**
* A boolean flag indicating that the button is selected
*/
private var _is_selected:Boolean = false;

//————————————————–
// CONSTRUCTOR
//————————————————–
/**
* Constructor
*/
public function BasicButton()
{
_instance = this;

init();
}

//————————————————–
// GETTERS / SETTERS
//————————————————–
/**
* Returns the fully qualified class path which includes the class package and class name as a string
* @return - String representing the full class path.
* For example: com.jasonwoan.display.BasicButton
*/

public function get fullyQualifiedClassPath():String
{
return BasicButton.FULLY_QUALIFIED_CLASS_PATH;
}

/**
* Returns the button’s on state.
* @return
*/

public function get on():Boolean
{
return _is_on;
}

/**
* Sets button’s on state.
* @param p_param (Boolean)
* @return void
*/

public function set on(p_param:Boolean):void
{
_is_on = p_param;

if (_is_on) {
_instance.mouseEnabled = true;
_instance.gotoAndStop(”up”);
} else {
_instance.mouseEnabled = false;
_instance.gotoAndStop(”off”);
}
}

/**
* Returns the button’s id.
* @return
*/
public function get id():uint
{
return _id;
}

/**
* Sets the button’s id.
* @param p_param (uint)
* @return void
*/
public function set id(p_param:uint):void
{
_id = p_param;
}

/**
* Returns the button’s selected state.
* @return
*/
public function get selected():Boolean
{
return _is_selected;
}

/**
* Sets the button’s selected state.
* @param
* @return void
*/
public function set selected(p_param:Boolean):void
{
_is_selected = p_param;

if (_is_selected) {
_instance.gotoAndStop(”over_hold”);
_instance.mouseEnabled = false;
} else {
_instance.gotoAndStop(”up”);
_instance.mouseEnabled = true;
}
}

//————————————————–
// EVENT HANDLERS
//————————————————–

/**
* Invoked when the button is rolled over.
* @param p_event (MouseEvent)
* @return void
*/
private function onButtonRollOver(p_event:MouseEvent):void
{
if (_is_on) {
_instance.gotoAndPlay(”over”);
} else {
_instance.gotoAndStop(”off”);
}
}

/**
* Invoked when the button is rolled out.
* @param p_event (MouseEvent)
* @return void
*/
private function onButtonRollOut(p_event:MouseEvent):void
{
if (_is_on) {
_instance.gotoAndPlay(”out”);
} else {
_instance.gotoAndStop(”off”);
}
}

//————————————————–
// PUBLIC METHODS
//————————————————–

/**
* Destroys this object for garbage collection.
* @return void
*/
public function destroy():void
{
destroyListeners();
_instance = null;
}

//————————————————–
// PRIVATE METHODS
//————————————————–

/**
* Initializes class instance.
* @return void
*/
private function init():void
{
createListeners();

_instance.buttonMode = true;
_instance.mouseChildren = false;
_instance.on = true;

// check to see if hit area mc exists, if so assign it as the hit area
var hit:Sprite = _instance.getChildByName(”hit_mc”) as Sprite;
if (hit) {
_instance.hitArea = hit;
}
}

/**
* Creates event listeners for the button.
* @return void
*/
private function createListeners():void
{
_instance.addEventListener(MouseEvent.ROLL_OVER, onButtonRollOver);
_instance.addEventListener(MouseEvent.ROLL_OUT, onButtonRollOut);
_instance.addEventListener(MouseEvent.MOUSE_UP, onButtonMouseUp);
}

/**
* Removes event listeners for the button.
* @return void
*/
private function destroyListeners():void
{
_instance.removeEventListener(MouseEvent.ROLL_OVER, onButtonRollOver);
_instance.removeEventListener(MouseEvent.ROLL_OUT, onButtonRollOut);
_instance.removeEventListener(MouseEvent.MOUSE_UP, onButtonMouseUp);
}
}
}

[/cc]

1. Install the Flash Switcher extension.
2. Save your current Flash Player version.  Firefox > Tools > Flash Switcher > Save as…
3. Run the Flash Player uninstaller.
4. Install a new version of Flash Player.
5. Repeat Step 2 & 3.
6. Select a Flash Player to run using Flash Switcher.

That’s it!  Hopefully, FP10 Debug for PPC will be released soon.

• Eclipse (Ganymede Release) w/ the FDT 3 Plugin. I love the templating feature of the FDT3 editor. I will post a few of my commonly used templates.
• Subclipse Plugin for version control.
• Flash Player 9 Debugger. Yes, I’m still using a PowerPC.
• Flash Tracer Firefox extension
• OS X Terminal command file tracer.  Add the following to a text file and save it as “debug.command”.  Fire it up in Terminal to read trace statements.[cc lang="php" tab_size="2" lines="40"]
  > /Users/USERNAME/Library/Preferences/Macromedia/Flash\ Player/Logs/flashlog.txt
  clear
  echo Terminal is observing the Flash log file. Type Ctrl-c to exit.
  echo
  tail -f /Users/USERNAME/Library/Preferences/Macromedia/Flash\ Player/Logs/flashlog.txt
  [/cc]
• Actionscript 3.0 Language and Components Reference.  My development bible.
• Doc? Air Local LiveDocs.  An AIR application that lets you peruse through reference docs.

CodeColorer

Installation is straightforward.  Here is a sample of what you get:

[cc lang="actionscript" tab_size="2" lines="40"]
// actionscript code
var mc:MovieClip = new MovieClip();
if (mc.x == 0) {
mc.x = 100;
}
[/cc]