[AS3] BasicScrollBar (no buttons)

package {
import flash.display.MovieClip;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.geom.Rectangle;

public class BasicScrollBar {
private var _mcScrollBar:MovieClip;

private var _mcScrollArea:MovieClip; // the area under the scroller
private var _mcScroller:MovieClip; // the scroller is the thing that you can drag to scroll
private var _mcScrolled:MovieClip; // the area that is actually scrolled
private var _mcScrolledMask:MovieClip; // mask for scrolled

private var _scrollTrack:Rectangle;

protected var _nScrollerLocation:Number; // a 0~1 value

public function BasicScrollBar(mcScrollBar:MovieClip) {
_mcScrollBar = mcScrollBar;

_mcScrollArea = _mcScrollBar.getChildByName(“mcScrollArea”) as MovieClip;
_mcScroller = _mcScrollBar.getChildByName(“mcScroller”) as MovieClip;
_mcScrolled = _mcScrollBar.getChildByName(“mcScrolled”) as MovieClip;
_mcScrolledMask = _mcScrollBar.getChildByName(“mcScrolledMask”) as MovieClip;
_mcScrolled.mask = _mcScrolledMask;

_scrollTrack = new Rectangle(_mcScroller.width/2, 0, 0, _mcScrollArea.height – _mcScroller.height); // scroll track

_mcScroller.addEventListener(MouseEvent.MOUSE_DOWN, OnMouseDown);
}

private function OnMouseDown(e:MouseEvent):void {
_mcScroller.startDrag(false, _scrollTrack);

_mcScrollBar.stage.addEventListener(MouseEvent.MOUSE_MOVE, OnMouseMoveHandler);
_mcScrollBar.stage.addEventListener(MouseEvent.MOUSE_UP, OnMouseUpHandler);
}

private function OnMouseMoveHandler(e:MouseEvent):void {
_nScrollerLocation = – (_mcScroller.y) / (_mcScrollArea.height – _mcScroller.height);
SetScrolled( _nScrollerLocation );
}

private function OnMouseUpHandler(e:MouseEvent):void {
_mcScroller.stopDrag();

_mcScrollBar.stage.removeEventListener(MouseEvent.MOUSE_MOVE, OnMouseMoveHandler);
_mcScrollBar.stage.removeEventListener(MouseEvent.MOUSE_UP, OnMouseUpHandler);
}

private function SetScrolled(nLocation:Number):void { // takes values between 0~1
var nScrollBarTotalHeight:Number = _mcScrollArea.height;
var nScrollAmountTotal:Number = _mcScrolled.height – nScrollBarTotalHeight;
var nNewPosition:Number = nLocation * nScrollAmountTotal;

if (nNewPosition <= 0) {
_mcScrolled.y = nNewPosition;
}
}
}
}

[AS3] RandomNumber

private function RandomNumber(low:Number=0, high:Number=1):Number {
return Math.floor(Math.random() * (1+high-low)) + low;
}

[AS3] ScrollBar

package {
import __AS3__.vec.Vector;
import flash.display.MovieClip;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.geom.Rectangle;

public class BasicScrollBar extends MovieClip {
protected var _mcUpArrow:MovieClip;
protected var _mcDownArrow:MovieClip;
protected var _mcScroller:MovieClip; // the scroller is the thing that you can drag to scroll
protected var _mcScrollArea:MovieClip; // the area under the scroller
protected var _mcScrolled:MovieClip; // the area that is actually scrolled
protected var _mcScrolledMask:MovieClip; // mask for scrolled

protected var _scrollTrack:Rectangle; // the scroller track (limits the movement)

protected var _nScrollerLocation:Number; // a 0~1 value

protected var _nScrollSpeed:Number;

public function BasicScrollBar() {
init();
initListeners();
}

public function cleanUp():void {
_mcUpArrow.removeEventListener(MouseEvent.CLICK, onUpArrow);
_mcDownArrow.removeEventListener(MouseEvent.CLICK, onDownArrow);
_mcScroller.removeEventListener(MouseEvent.MOUSE_DOWN, onScroll);
}

private function init():void {
_mcUpArrow = getChildByName(“mcUpArrow”) as MovieClip;
_mcDownArrow = getChildByName(“mcDownArrow”) as MovieClip;
_mcScroller = getChildByName(“mcScroller”) as MovieClip;
_mcScrollArea = getChildByName(“mcScrollArea”) as MovieClip;
_mcScrolled = getChildByName(“mcScrolled”) as MovieClip;
_mcScrolledMask = getChildByName(“mcScrolledMask”) as MovieClip;

_mcScrolledMask.width = Math.abs(_mcScrolled.x);
_mcScrolledMask.height = _mcUpArrow.height + _mcScrollArea.height + _mcDownArrow.height;
_mcScrolled.mask = _mcScrolledMask;

_scrollTrack = new Rectangle(0, _mcScroller.height, 0, _mcScrollArea.height – _mcScroller.height); // scroll track

_nScrollSpeed = 10;
}

private function initListeners():void {
_mcUpArrow.buttonMode = true;
_mcDownArrow.buttonMode = true;
//            _mcScroller.buttonMode = true;

_mcUpArrow.addEventListener(MouseEvent.CLICK, onUpArrow);
_mcDownArrow.addEventListener(MouseEvent.CLICK, onDownArrow);
_mcScroller.addEventListener(MouseEvent.MOUSE_DOWN, onScroll);
}

private function onUpArrow(e:MouseEvent):void { // clicked up arrow
if ( _mcScroller.y > _mcUpArrow.height ) {
_mcScroller.y = _mcScroller.y – _nScrollSpeed;

if (_mcScroller.y < _mcUpArrow.height) { _mcScroller.y = _mcUpArrow.height; }
}

_nScrollerLocation = – ((_mcUpArrow.height – _mcScroller.y) / (_mcScrollArea.height – _mcScroller.height));
setScrolled( _nScrollerLocation );
}

private function onDownArrow(e:MouseEvent):void { // clicked down arrow
if ( _mcScroller.y < _mcScrollArea.height ) {
_mcScroller.y = _mcScroller.y + _nScrollSpeed;

if ( _mcScroller.y > _mcScrollArea.height ) { _mcScroller.y = _mcScrollArea.height; }
}

_nScrollerLocation = – ((_mcUpArrow.height – _mcScroller.y) / (_mcScrollArea.height – _mcScroller.height));
setScrolled( _nScrollerLocation );
}

private function onScroll(e:MouseEvent):void {
_mcScroller.startDrag(false, _scrollTrack); // move the scrollbar

stage.addEventListener(MouseEvent.MOUSE_MOVE, onMouseMoveHandler);
stage.addEventListener(MouseEvent.MOUSE_UP, onMouseUpHandler);
}

private function onMouseMoveHandler(e:MouseEvent):void {
_nScrollerLocation = – ((_mcUpArrow.height – _mcScroller.y) / (_mcScrollArea.height – _mcScroller.height));

setScrolled( _nScrollerLocation );
}

private function onMouseUpHandler(e:MouseEvent):void {
_mcScroller.stopDrag();

stage.removeEventListener(MouseEvent.MOUSE_MOVE, onMouseMoveHandler);
stage.removeEventListener(MouseEvent.MOUSE_UP, onMouseUpHandler);
}

private function setScrolled(nLocation:Number):void { // takes values between 0~1
var nScrollBarTotalHeight:Number = _mcUpArrow.height + _mcScrollArea.height + _mcDownArrow.height;
var nScrollAmountTotal:Number = _mcScrolled.height – nScrollBarTotalHeight;
var nNewPosition:Number = -nLocation * nScrollAmountTotal;

if (nNewPosition <= 0) {
_mcScrolled.y = nNewPosition;
}
}
}
}

[AS3] Mp3Loader

package {
import flash.events.Event;
import flash.events.EventDispatcher;
import flash.media.Sound;
import flash.media.SoundChannel;
import flash.media.SoundTransform;
import flash.net.URLRequest;

public class Mp3Loader extends EventDispatcher {
public static const LOADED:String = “loaded”;
public static const FINISHED_PLAYING:String = “finishedPlaying”;

private var _url:String;
private var _sound:Sound;
private var _channel:SoundChannel;

public function Mp3Loader(url:String) {
_url = url;
_sound = new Sound(new URLRequest(_url));
_sound.addEventListener(Event.COMPLETE, OnMp3Loaded);
}

/* GETTERS *******************************************************************************/
public function get channel():SoundChannel {
return _channel;
}

public function get sound():Sound {
return _sound;
}

/* SETTERS *******************************************************************************/
public function PlayMusic():void {
_channel = _sound.play();
_channel.addEventListener(Event.SOUND_COMPLETE, OnSongOver);
}

public function StopMusic():void {
if (_channel != null) {
_channel.removeEventListener(Event.SOUND_COMPLETE, OnSongOver);
_channel.stop();
}
}

/* EVENT DISPATCHERS *********************************************************************/
private function OnMp3Loaded(e:Event):void {
dispatchEvent(new Event(Mp3Loader.LOADED));
}

private function OnSongOver(e:Event):void {
dispatchEvent(new Event(Mp3Loader.FINISHED_PLAYING));
}
}
}

[AS3] BasicButton

package {
import flash.display.MovieClip;
import flash.events.Event;
import flash.events.MouseEvent;

public class BasicButton {
public static const UP:String = “up”;
public static const OVER:String = “over”;
public static const DOWN:String = “down”;
public static const DISABLE:String = “disable”;

private var _mc:MovieClip;
private var _handler:Function;
private var _enabled:Boolean; // enable/disable

public function BasicButton(mc:MovieClip, handler:Function=null) {
_mc = mc;
_handler = handler;
_enabled = true;

_mc.gotoAndStop(UP);

_mc.buttonMode = true;
_mc.useHandCursor = true;

_mc.addEventListener(MouseEvent.MOUSE_OVER, myMouseOver);
_mc.addEventListener(MouseEvent.MOUSE_OUT, myMouseOut);
_mc.addEventListener(MouseEvent.MOUSE_DOWN, myMouseDown);
}

/* CLEANUP ******************************************************************/
public function destroy():void {
_mc.removeEventListener(MouseEvent.MOUSE_OVER, myMouseOver);
_mc.removeEventListener(MouseEvent.MOUSE_OUT, myMouseOut);
_mc.removeEventListener(MouseEvent.MOUSE_DOWN, myMouseDown);
}

/* SETTERS ******************************************************************/
public function enable(b:Boolean):void {
_enabled = b;
_mc.buttonMode = _enabled;
_mc.useHandCursor = _enabled;

if (_enabled) {
_mc.gotoAndStop(UP);
}
else {
_mc.gotoAndStop(DISABLE);
}
}

/* HANDLERS *****************************************************************/
private function myMouseOver(e:MouseEvent):void {
if (_enabled) { // if it’s not disabled…
_mc.gotoAndStop(OVER);
}
}

private function myMouseOut(e:MouseEvent):void {
if (_enabled) { // if it’s not disabled…
_mc.gotoAndStop(UP);
}
}

private function myMouseDown(e:MouseEvent):void {
if (_enabled) { // if it’s not disabled…
_mc.gotoAndStop(DOWN);

_mc.stage.addEventListener(MouseEvent.MOUSE_UP, myMouseUp);
}
}

private function myMouseUp(e:MouseEvent):void {
_mc.stage.removeEventListener(MouseEvent.MOUSE_UP, myMouseUp);

if (_mc.hitTestPoint(_mc.stage.mouseX, _mc.stage.mouseY)) {
_mc.gotoAndStop(UP);
_handler();
}
else {
_mc.gotoAndStop(UP);
}
}
}
}

[AS3] SwfLoader

package {
import flash.display.Loader;
import flash.display.LoaderInfo;
import flash.net.URLRequest;
import flash.events.Event;
import flash.events.ProgressEvent;
import flash.events.EventDispatcher;

public class SwfLoader extends EventDispatcher {
public static var LOADED:String = “loaded”;

private var _myLoader:Loader;
private var _myLoaderInfo:LoaderInfo;
private var _myURLRequest:URLRequest;
private var _mySwf:Object;
private var _mySwfClass:Object;
private var _mySwfPercentLoaded:uint;
private var _myPreLoaderBar:Object;

public function SwfLoader(url:String, preLoaderBar:Object=null) {
_myLoader = new Loader();
_myURLRequest = new URLRequest(url);
_myPreLoaderBar = preLoaderBar;

_myLoader.contentLoaderInfo.addEventListener(ProgressEvent.PROGRESS, OnProgressHandler);
_myLoader.contentLoaderInfo.addEventListener(Event.COMPLETE, OnLoadComplete);
_myLoader.load(_myURLRequest);
}

public function get PercentLoaded():uint {
return _mySwfPercentLoaded;
}

public function get Swf():Object {
return _mySwf;
}

public function get SwfClass():Object {
return _mySwfClass;
}

/* EVENT HANDLER *************************************************************************/
private function OnProgressHandler(e:ProgressEvent):void {
if(_myPreLoaderBar != null) { // if a preloader bar has been given, pass percentage loaded
_mySwfPercentLoaded = uint( (e.bytesLoaded / e.bytesTotal) * 100 );
_myPreLoaderBar.SetPercent(_mySwfPercentLoaded);
}
}

private function OnLoadComplete(e:Event):void {
_mySwf = e.target.content; // same as _myLoader.content;

_myLoaderInfo = e.target as LoaderInfo;
_mySwfClass = _myLoaderInfo.content;

dispatchEvent(new Event(SwfLoader.LOADED));
}
}
}

[AS3] External Wav Player

[WavPlayer.as]

package {
import flash.events.Event;
import flash.events.ProgressEvent;
import flash.events.EventDispatcher;
import flash.events.IOErrorEvent;
import flash.net.URLRequest;
import flash.net.URLStream;
import flash.media.SoundChannel;
import flash.utils.ByteArray;
import flash.utils.Endian;
import flash.display.Loader;
import flash.display.LoaderInfo;
import flash.media.Sound;
import flash.media.SoundTransform;
import flash.media.SoundChannel;

public class WavPlayer {
private var _myUrl:String;
private var _byteStream:URLStream;
private var _wavFormat:PCMFormat;
private var _sound:Sound;
private var _channel:SoundChannel;

public function WavPlayer(myUrl:String = null) {
super();

Init();
InitListeners();

Load(myUrl);
}

/* PUBLIC ********************************************************************************/
public function Load(myUrl:String = null):void {
if (myUrl != null) {
_myUrl = myUrl;

var myUrlRequest:URLRequest = new URLRequest(myUrl);
_byteStream.load(myUrlRequest);
}
}

public function CleanUp():void {
_byteStream.removeEventListener(ProgressEvent.PROGRESS, LoadProgress);
_byteStream.removeEventListener(Event.COMPLETE, LoadComplete);
_byteStream.removeEventListener(IOErrorEvent.IO_ERROR, LoadError);
}

/* INIT **********************************************************************************/
private function Init():void {
_myUrl = “”;
_byteStream = new URLStream();
}

private function InitListeners():void {
_byteStream.addEventListener(ProgressEvent.PROGRESS, LoadProgress);
_byteStream.addEventListener(Event.COMPLETE, LoadComplete);
_byteStream.addEventListener(IOErrorEvent.IO_ERROR, LoadError);
}

/* EVENT HANDLERS ************************************************************************/
private function LoadProgress(e:ProgressEvent):void {
trace(“bytesLoaded/bytesTotal: “+e.bytesLoaded.toString()+”/”+e.bytesTotal.toString());
}

private function LoadError(e:IOErrorEvent):void {
trace(“loadError”);
}

private function LoadComplete(e:Event):void {
trace(“loading complete… analyzing header…”);

var wavHeader:ByteArray = new ByteArray(); wavHeader.endian = Endian.LITTLE_ENDIAN;
var wavData:ByteArray = new ByteArray(); wavData.endian = Endian.LITTLE_ENDIAN;

_byteStream.readBytes(wavHeader, 0, PCMFormat.HEADER_SIZE);
_wavFormat = new PCMFormat();

try {
_wavFormat.AnalyzeHeader(wavHeader);
} catch (e:Error) {
trace(e);
return;
}

var bytesToRead:uint = _byteStream.bytesAvailable < _wavFormat._waveDataLength ? _byteStream.bytesAvailable : _wavFormat._waveDataLength;
_byteStream.readBytes(wavData, 0, bytesToRead);
var swf:SWFFormat = new SWFFormat(_wavFormat);
var compiledSWF:ByteArray = swf.CompileSWF(wavData);
var compiledSWFLoader:Loader = new Loader();
compiledSWFLoader.loadBytes(compiledSWF);
compiledSWFLoader.contentLoaderInfo.addEventListener(Event.COMPLETE, generateCompleteHandler);
}

private function generateCompleteHandler(e:Event):void {
var soundClass:Class = LoaderInfo(e.target).applicationDomain.getDefinition(SWFFormat.CLASS_NAME) as Class;
_sound = new soundClass() as Sound;
_sound.play(0, 0, null);
}
}
}

[PCMFormat.as]

package {
import flash.utils.ByteArray;

public class PCMFormat {
/* CLASS PROPERTIES **********************************************************************/
public static const HEADER_SIZE:uint = 44;

public var _channels:uint;
public var _sampleRate:uint;
public var _byteRate:uint;
public var _blockAlign:uint;
public var _bitsPerSample:uint;
public var _waveDataLength:uint;
public var _fullDataLength:uint;

/* CONSTRUCTOR ***************************************************************************/
public function PCMFormat() {

}

/* PUBLIC METHODS ************************************************************************/
public function AnalyzeHeader(byteArray:ByteArray):void {
var typeArray:ByteArray = new ByteArray();
byteArray.readBytes(typeArray, 0, 4);

if (typeArray.toString() != “RIFF”) {
throw new Error(“Error: incorrect RIFF header”);
return;
}

_fullDataLength = byteArray.readUnsignedInt()+8;
byteArray.position = 0×10;
var chunkSize:Number = byteArray.readUnsignedInt();

if (chunkSize != 0×10) {
throw new Error(“Error: incorrect chunk size”);
return;
}

var isPCM:Boolean = Boolean(byteArray.readShort());

if (!isPCM) {
throw new Error(“Error: this file is not PCM wave file”);
return;
}

_channels = byteArray.readShort();
_sampleRate = byteArray.readUnsignedInt();

switch (_sampleRate) {
case 44100:
case 22050:
case 11025:
case 5512:
break;
default:
throw new Error(“Decode error: incorrect sample rate”);
return;
}

_byteRate = byteArray.readUnsignedInt();
_blockAlign = byteArray.readShort();
_bitsPerSample = byteArray.readShort();
byteArray.position += 0×04;
_waveDataLength = byteArray.readUnsignedInt();

if (!_blockAlign) {
_blockAlign = _channels*_bitsPerSample/8;
}

byteArray.position = 0;
}
}
}

[SWFFormat.as]

package {
import flash.utils.ByteArray;
import flash.utils.Endian;

import PCMFormat;

public class SWFFormat {
/* CLASS PROPERTIES **********************************************************************/
private static const SWF_PART0:String = “46575309″;
private static const SWF_PART1:String = “7800055F00000FA000000C01004411080000004302FFFFFFBF150B00000001005363656E6520310000BF14C7000000010000000010002E00000000080013574156506C61796572536F756E64436C6173730B666C6173682E6D6564696105536F756E64064F626A6563740C666C6173682E6576656E74730F4576656E744469737061746368657205160116031802160600050701020702040701050704070300000000000000000000000000010102080300010000000102010104010003000101050603D030470000010101060706D030D04900470000020201010517D0306500600330600430600230600258001D1D1D6801470000BF03″;
private static const SWF_PART2:String = “3F131800000001000100574156506C61796572536F756E64436C61737300440B0800000040000000″;

public static const CLASS_NAME:String = “WAVPlayerSoundClass”;

private var _pcmFormat:PCMFormat;

/* CONSTRUCTOR ***************************************************************************/
public function SWFFormat(format:PCMFormat) {
_pcmFormat = format;
}

/* PRIVATE METHODS ***********************************************************************/
private function WriteBytesFromString(byteArray:ByteArray, bytesHexString:String):void {
var length:uint = bytesHexString.length;

for (var i:uint = 0;i<length;i+=2) {
var hexByte:String = bytesHexString.substr(i, 2);
var byte:uint = Number(“0x”+hexByte);
byteArray.writeByte(byte);
}
}

private function TraceArray(array:ByteArray):String { // for debug
var out:String = “”;
var pos:uint = array.position;
array.position = 0;

while (array.bytesAvailable) {
var str:String = array.readUnsignedByte().toString(16).toUpperCase();
str = str.length < 2 ? “0″+str : str;
out += str+’ ‘;
}

array.position = pos;
return out;
}

private function GetFormatByte():uint {
var byte:uint = (_pcmFormat._bitsPerSample == 0×10) ? 0×32 : 0×00;
byte += (_pcmFormat._channels-1);
byte += 4*(Math.floor(_pcmFormat._sampleRate/5512.5).toString(2).length-1); //
return byte;
}

/* PUBLIC METHODS ************************************************************************/
public function CompileSWF(audioData:ByteArray):ByteArray {
var dataLength:uint = audioData.length;
var swfSize:uint = dataLength+307;
var totalSamples:uint = dataLength/_pcmFormat._blockAlign;
var output:ByteArray = new ByteArray();
output.endian = Endian.LITTLE_ENDIAN;
WriteBytesFromString(output, SWFFormat.SWF_PART0);
output.writeUnsignedInt(swfSize);
WriteBytesFromString(output, SWFFormat.SWF_PART1);
output.writeUnsignedInt(dataLength+7);
output.writeByte(1);
output.writeByte(0);
output.writeByte(GetFormatByte());
output.writeUnsignedInt(totalSamples);
output.writeBytes(audioData);
WriteBytesFromString(output, SWFFormat.SWF_PART2);
return output;
}
}
}

[AS3] XOR Ciper

package {
public class XORcipher {
public var _sKEY:String;

public function XORcipher(xorKEY:String) {
_sKEY = xorKEY;
}

// use to generate a random key
public static function generateRandomKey( nLength:int, sCharsToUse:String=”0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz”):String {
var aResult:Array = new Array();
var i:int;

while (nLength–) {
i = Math.floor(Math.random()*sCharsToUse.length);
aResult.push(sCharsToUse.charAt(i));
}

return aResult.join(“”);
}

// encrypt string data
public function encrypt(sSource:String):String {
return escape(xor(sSource));
}

// decrypt string data
public function decrypt(sSource:String):String {
return xor(unescape(sSource));
}

private function xor(sSource:String):String {
var aResult:Array = new Array();
var nKeyLength:int = _sKEY.length;
var fTempFunc:Function = String.fromCharCode;

for (var i:int=0; i<sSource.length; ++i) {
aResult.push( fTempFunc( sSource.charCodeAt(i)^_sKEY.charCodeAt(i%nKeyLength) ) );
}

return aResult.join(“”);
}
}
}

[AS3] Calculate distance between two xy points

private function calcDistance(nX1:Number, nY1:Number, nX2:Number, nY2:Number):Number {
var dist:Number;
var dx:Number;
var dy:Number;

dx = nX2-nX1;
dy = nY2-nY1;
dist = Math.sqrt(dx*dx + dy*dy);

return dist;
}

[AS3] ImageLoader

package {
import flash.display.Sprite;
import flash.display.Loader;
import flash.net.URLRequest;
import flash.events.Event;
import flash.events.IOErrorEvent;
import flash.events.ProgressEvent;

public class ImageLoader extends Sprite {
private var _imageLoader:Loader;
private var _iWidth:int;
private var _iHeight:int;
private var _nPercentLoaded:Number; // a value of 0~100

public function ImageLoader( sUrl:String, width:int, height:int ) {
_imageLoader = new Loader();
_imageLoader.load(new URLRequest( sUrl )); _iWidth = width; _iHeight = height;

_imageLoader.contentLoaderInfo.addEventListener(ProgressEvent.PROGRESS, onLoadProgress);
_imageLoader.contentLoaderInfo.addEventListener(Event.COMPLETE, onLoadComplete);

_imageLoader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, catch_function);
}

private function onLoadProgress(e:ProgressEvent):void {
_nPercentLoaded = e.bytesLoaded / e.bytesTotal;
_nPercentLoaded = Math.round(_nPercentLoaded * 100);
}

private function onLoadComplete(e:Event):void {
addChild( _imageLoader );
_imageLoader.width = _iWidth;
_imageLoader.height = _iHeight;
}

private function catch_function(e:IOErrorEvent):void {
// couldn’t find the file
}
}
}