gotoAndPlay – A great flash resource

http://www.gotoandplay.it/

Movieclip Tweening Prototypes

http://laco.wz.cz/tween/

Hybrid City – Flash 8

This is one of the first flash 8 sites created. it is HUGE, so be patient, also the japanese girl who guides you can be a bit annoying, but it’s brilliant, some lovely effects using the new features of flash 8. very nicely designed and put together. Prepare for a lot of loading but very nice.. http://www.hybridcity.jp/

Underworld Evolution Trailer – Flash 8

A little flash 8 trailer that macromedia made for sony is here, this uses the some of the new features very subtly, good piece of work. http://www.sonypictures.com/movies/underworldevolution/

phpMyAdmin in flash

http://www.flashmyadmin.org/english/download.php

Penner colour equations – flash script .as

//create a negative image – invert all colors
Color.prototype.negative = function () {
var trans = new Object();
trans.ra = trans.ga = trans.ba = -100;
trans.rb = trans.gb = trans.bb = 255;
this.setTransform(trans);
}//Robert Penner June 2001 – www.robertpenner.com

//tint an object with a color just like Effect panel
//r, g, b between 0 and 255; amount between 0 and 100
Color.prototype.setTint = function (r, g, b, amount) {
var percent = 100 – amount;
var trans = new Object();
trans.ra = trans.ga = trans.ba = percent;
var ratio = amount / 100;
trans.rb = r * ratio;
trans.gb = g * ratio;
trans.bb = b * ratio;
this.setTransform(trans);
}//Robert Penner June 2001 – www.robertpenner.com

//brighten an object just like Effect panel
//bright between 0 and 100
Color.prototype.setBrightness = function (bright) {
var percent = 100 – Math.abs(bright);
var offset = 0;
if (bright > 0) offset = 256 * (bright / 100);
var trans = new Object();
trans.ra = trans.ga = trans.ba = percent;
trans.rb = trans.gb = trans.bb = offset;
this.setTransform(trans);
}//Robert Penner June 2001 – www.robertpenner.com

//push an object’s colors around – interesting fx
//r, g, b between -255 and 255
Color.prototype.setTintOffset = function (r, g, b) {
var trans = new Object();
trans.rb = r;
trans.gb = g;
trans.bb = b;
this.setTransform(trans);
}//Robert Penner June 2001 – www.robertpenner.com

//push an object’s brightness around – fx like eneri.net
//offset between -255 and 255
Color.prototype.setBrightOffset = function (offset) {
var trans = new Object();
trans.rb = trans.gb = trans.bb = offset;
this.setTransform(trans);
}//Robert Penner June 2001 – www.robertpenner.com

//reset the color object to normal
Color.prototype.reset = function () {
var trans = new Object();
trans.ra = trans.ga = trans.ba = 100;
trans.rb = trans.gb = trans.bb = 0;
this.setTransform(trans);
}//Robert Penner June 2001 – www.robertpenner.com

// EXAMPLE ON A MOVIE CLIP
onClipEvent (load) {
meCol = new Color(this);
meCol.negative();
}

Number formatting

// usage: value=format(“12345678″); OR value=format(12345678);
function format(p){
n = String(p);
numArray = new Array();
for (i = 0; i< n.length ; i++){
numArray.push(n.substr(i,1));
}
countv = 0;
val = “”;
for (c = 0; c < n.length; c++){
if (countv < 3){
val = numArray.pop() + val;
countv++;
} else {
val = numArray.pop() + “,”+val;
countv = 1;
}
}
return val;
}

Shuffle

//usage arrayHere.shuff();
Array.prototype.shuff = function (times) {
if (times == null) {
times = 5;
}
var pos1, pos2, temp;
for (var i = 0; i< (this.length*times); ++i) {
pos1 = random(this.length);
pos2 = random(this.length);
temp = this[pos1];
this[pos1] = this[pos2];
this[pos2] = temp;
}
};

Motion – flash script .as

///////////// QUADRATIC EASING: t^2 ///////////////////

// quadratic easing in – accelerating from zero velocity
// t: current time, b: beginning value, c: change in value, d: duration
// t and d can be in frames or seconds/milliseconds
Math.easeInQuad = function (t, b, c, d) {
return c*(t/=d)*t + b;
};

// quadratic easing out – decelerating to zero velocity
Math.easeOutQuad = function (t, b, c, d) {
return -c *(t/=d)*(t-2) + b;
};

// quadratic easing in/out – acceleration until halfway, then deceleration
Math.easeInOutQuad = function (t, b, c, d) {
if ((t/=d/2) < 1) return c/2*t*t + b;
return -c/2 * ((–t)*(t-2) – 1) + b;
};
///////////// QUARTIC EASING: t^4 /////////////////////

// quartic easing in – accelerating from zero velocity
// t: current time, b: beginning value, c: change in value, d: duration
// t and d can be frames or seconds/milliseconds
Math.easeInQuart = function (t, b, c, d) {
return c*(t/=d)*t*t*t + b;
};

// quartic easing out – decelerating to zero velocity
Math.easeOutQuart = function (t, b, c, d) {
return -c * ((t=t/d-1)*t*t*t – 1) + b;
};

// quartic easing in/out – acceleration until halfway, then deceleration
Math.easeInOutQuart = function (t, b, c, d) {
if ((t/=d/2) < 1) return c/2*t*t*t*t + b;
return -c/2 * ((t-=2)*t*t*t – 2) + b;
};
///////////// QUINTIC EASING: t^5 ////////////////////

// quintic easing in – accelerating from zero velocity
// t: current time, b: beginning value, c: change in value, d: duration
// t and d can be frames or seconds/milliseconds
Math.easeInQuint = function (t, b, c, d) {
return c*(t/=d)*t*t*t*t + b;
};

// quintic easing out – decelerating to zero velocity
Math.easeOutQuint = function (t, b, c, d) {
return c*((t=t/d-1)*t*t*t*t + 1) + b;
};

// quintic easing in/out – acceleration until halfway, then deceleration
Math.easeInOutQuint = function (t, b, c, d) {
if ((t/=d/2) < 1) return c/2*t*t*t*t*t + b;
return c/2*((t-=2)*t*t*t*t + 2) + b;
};
///////////// CUBIC EASING: t^3 ///////////////////////

// cubic easing in – accelerating from zero velocity
// t: current time, b: beginning value, c: change in value, d: duration
// t and d can be frames or seconds/milliseconds
Math.easeInCubic = function (t, b, c, d) {
return c*(t/=d)*t*t + b;
};

// cubic easing out – decelerating to zero velocity
Math.easeOutCubic = function (t, b, c, d) {
return c*((t=t/d-1)*t*t + 1) + b;
};

// cubic easing in/out – acceleration until halfway, then deceleration
Math.easeInOutCubic = function (t, b, c, d) {
if ((t/=d/2) < 1) return c/2*t*t*t + b;
return c/2*((t-=2)*t*t + 2) + b;
};
/////////// BOUNCE EASING: exponentially decaying parabolic bounce //////////////

// bounce easing in
// t: current time, b: beginning value, c: change in position, d: duration
Math.easeInBounce = function (t, b, c, d) {
return c – Math.easeOutBounce (d-t, 0, c, d) + b;
};

// bounce easing out
Math.easeOutBounce = function (t, b, c, d) {
if ((t/=d) < (1/2.75)) {
return c*(7.5625*t*t) + b;
} else if (t < (2/2.75)) {
return c*(7.5625*(t-=(1.5/2.75))*t + .75) + b;
} else if (t < (2.5/2.75)) {
return c*(7.5625*(t-=(2.25/2.75))*t + .9375) + b;
} else {
return c*(7.5625*(t-=(2.625/2.75))*t + .984375) + b;
}
};

// bounce easing in/out
Math.easeInOutBounce = function (t, b, c, d) {
if (t < d/2) return Math.easeInBounce (t*2, 0, c, d) * .5 + b;
return Math.easeOutBounce (t*2-d, 0, c, d) * .5 + c*.5 + b;
};
/////////// BACK EASING: overshooting cubic easing: (s+1)*t^3 – s*t^2 //////////////

// back easing in – backtracking slightly, then reversing direction and moving to target
// t: current time, b: beginning value, c: change in value, d: duration, s: overshoot amount (optional)
// t and d can be in frames or seconds/milliseconds
// s controls the amount of overshoot: higher s means greater overshoot
// s has a default value of 1.70158, which produces an overshoot of 10 percent
// s==0 produces cubic easing with no overshoot
Math.easeInBack = function (t, b, c, d, s) {
if (s == undefined) s = 1.70158;
return c*(t/=d)*t*((s+1)*t – s) + b;
};

// back easing out – moving towards target, overshooting it slightly, then reversing and coming back to target
Math.easeOutBack = function (t, b, c, d, s) {
if (s == undefined) s = 1.70158;
return c*((t=t/d-1)*t*((s+1)*t + s) + 1) + b;
};

// back easing in/out – backtracking slightly, then reversing direction and moving to target,
// then overshooting target, reversing, and finally coming back to target
Math.easeInOutBack = function (t, b, c, d, s) {
if (s == undefined) s = 1.70158;
if ((t/=d/2) < 1) return c/2*(t*t*(((s*=(1.525))+1)*t - s)) + b;
return c/2*((t-=2)*t*(((s*=(1.525))+1)*t + s) + 2) + b;
};
/////////// ELASTIC EASING: exponentially decaying sine wave //////////////

// t: current time, b: beginning value, c: change in value, d: duration, a: amplitude (optional), p: period (optional)
// t and d can be in frames or seconds/milliseconds

Math.easeInElastic = function (t, b, c, d, a, p) {
if (t==0) return b; if ((t/=d)==1) return b+c; if (!p) p=d*.3;
if (a < Math.abs(c)) { a=c; var s=p/4; }
else var s = p/(2*Math.PI) * Math.asin (c/a);
return -(a*Math.pow(2,10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )) + b;
};

Math.easeOutElastic = function (t, b, c, d, a, p) {
if (t==0) return b; if ((t/=d)==1) return b+c; if (!p) p=d*.3;
if (a < Math.abs(c)) { a=c; var s=p/4; }
else var s = p/(2*Math.PI) * Math.asin (c/a);
return a*Math.pow(2,-10*t) * Math.sin( (t*d-s)*(2*Math.PI)/p ) + c + b;
};

Math.easeInOutElastic = function (t, b, c, d, a, p) {
if (t==0) return b; if ((t/=d/2)==2) return b+c; if (!p) p=d*(.3*1.5);
if (a < Math.abs(c)) { a=c; var s=p/4; }
else var s = p/(2*Math.PI) * Math.asin (c/a);
if (t < 1) return -.5*(a*Math.pow(2,10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )) + b;
return a*Math.pow(2,-10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )*.5 + c + b;
};
/////////// CIRCULAR EASING: sqrt(1-t^2) //////////////

// circular easing in – accelerating from zero velocity
// t: current time, b: beginning value, c: change in position, d: duration
Math.easeInCirc = function (t, b, c, d) {
return -c * (Math.sqrt(1 – (t/=d)*t) – 1) + b;
};

// circular easing out – decelerating to zero velocity
Math.easeOutCirc = function (t, b, c, d) {
return c * Math.sqrt(1 – (t=t/d-1)*t) + b;
};

// circular easing in/out – acceleration until halfway, then deceleration
Math.easeInOutCirc = function (t, b, c, d) {
if ((t/=d/2) < 1) return -c/2 * (Math.sqrt(1 - t*t) - 1) + b;
return c/2 * (Math.sqrt(1 – (t-=2)*t) + 1) + b;
};
///////////// EXPONENTIAL EASING: 2^t /////////////////

// exponential easing in – accelerating from zero velocity
// t: current time, b: beginning value, c: change in position, d: duration
Math.easeInExpo = function (t, b, c, d) {
return (t==0) ? b : c * Math.pow(2, 10 * (t/d – 1)) + b;
};

// exponential easing out – decelerating to zero velocity
Math.easeOutExpo = function (t, b, c, d) {
return (t==d) ? b+c : c * (-Math.pow(2, -10 * t/d) + 1) + b;
};

// exponential easing in/out – accelerating until halfway, then decelerating
Math.easeInOutExpo = function (t, b, c, d) {
if (t==0) return b;
if (t==d) return b+c;
if ((t/=d/2) < 1) return c/2 * Math.pow(2, 10 * (t - 1)) + b;
return c/2 * (-Math.pow(2, -10 * –t) + 2) + b;
};
///////////// SINUSOIDAL EASING: sin(t) ///////////////

// sinusoidal easing in – accelerating from zero velocity
// t: current time, b: beginning value, c: change in position, d: duration
Math.easeInSine = function (t, b, c, d) {
return -c * Math.cos(t/d * (Math.PI/2)) + c + b;
};

// sinusoidal easing out – decelerating to zero velocity
Math.easeOutSine = function (t, b, c, d) {
return c * Math.sin(t/d * (Math.PI/2)) + b;
};

// sinusoidal easing in/out – accelerating until halfway, then decelerating
Math.easeInOutSine = function (t, b, c, d) {
return -c/2 * (Math.cos(Math.PI*t/d) – 1) + b;
};
// simple linear tweening – no easing
// t: current time, b: beginning value, c: change in value, d: duration
Math.linearTween = function (t, b, c, d) {
return c*t/d + b;
};

The complete(ish) list of flash 8 new features

http://www.moock.org/blog/archives/000172.html