package com.actiontad.gameUtils
{
//import com.actiontad.gameUtils.RPEase;
/**
* Tween related math and functions.
* The tweenArray method is similar to the SimpleStaticTweener.calcProps method.
*/
public class TweenMath
{
public static const LINEAR:String = "Linear";
public static const IN:String = "In";
public static const OUT:String = "Out";
public static const IN_OUT:String = IN + OUT;
public static const IN_BOUNCE:String = IN + "Bounce";
public static const OUT_BOUNCE:String = OUT + "Bounce";
public static const IN_BACK:String = IN + "Back";
public static const OUT_BACK:String = OUT + "Back";
public static const IN_CIRC:String = IN + "Circ";
public static const OUT_CIRC:String = OUT + "Circ";
public static const IN_ELASTIC:String = IN + "Elastic";
public static const OUT_ELASTIC:String = OUT + "Elastic";
public static const IN_LINEAR:String = IN + LINEAR;
public static const OUT_LINEAR:String = OUT + LINEAR;
public static const IN_SINE:String = IN + "Sine";
public static const OUT_SINE:String = OUT + "Sine";
public static const IN_QUAD:String = IN + "Quad";
public static const OUT_QUAD:String = OUT + "Quad";
public static const easeOptions:Object = {
"Linear":true, "InLinear":true, "OutLinear":1, "InOutLinear":1, "InElastic":1,
"OutElastic":1, "InOutElastic":1, "InQuad":1, "OutQuad":1, "InOutQuad":1,
"InBounce":1, "InOutBounce":1, "OutBounce":1, "InCirc":1, "InBack":1, "OutBack":1, "InOutBack":1,
"InQuint":1, "OutQuint":1, "InOutQuint":1, "OutCirc":1, "InOutCirc":1,
"In":1, "Out":1, "InOut":1, "InSine":1, "OutSine":1, "InOutSine":1
};
/**
* Returns an Array of the numbers that will make up a tween from start to end(params) based on the how string (param).
* Usage:
* var tweenTo:Array = TweenMath.tweenArray( 0, 50, 999, TweenMath.IN_LINEAR );
* var les:LoopEventSubscriber = new LoopEventSubscriber();
* someEngine.addChild(les);
* les.addEventListener(GameObjectEvents.LOOP, tweenMe);
* private function tweenMe(e:Event):void { if (tweenTo.length >= 1) {les.x = tweenTo.shift();} }
*
* @param start Starting number.
* @param end Ending number.
* @param interval The amount of time the tween should take in seconds or milliseconds, default is in milliseconds.
* ( you must also factor in frame rate yourself if you choose useSeconds in loopOptions )
* @param how The easing function (string name) to use from the easeOptions or static properties.
* @param loopOptions .millisecondRate - default is 1000, applies only if using milliseconds.
* .frameRate - default is 30, the frame rate of the swf file, applies only if using milliseconds.
* .useSeconds - default is 0, pass a number greater than 0 to use seconds instead of milliseconds.
* When using seconds interval stands for the exact amount of seconds you want, otherwise it stands for milliseconds,
* and milliseconds will be calculated based on a default frame rate of 30 and millisecondRate of 1000.
*
*/
public static function tweenArray(start:Number, end:Number, interval:Number, how:String = "Linear", loopOptions:Object = null):Array {
var v:Array = []; var si:int = 0; var realHow:String = "Linear";
if (easeOptions[how]) { realHow = how; }
var ending:Number = end - start; si = 0;
var argsers:Array = [ ((realHow.indexOf("Back") != -1)?1.70158:0) , 0 ];
var millisecondRate:Number = ( loopOptions ? loopOptions.millisecondRate || 1000 : 1000 );
var frameRate:Number = ( loopOptions ? loopOptions.frameRate || 30 : 30 );
var useSeconds:int = ( loopOptions ? loopOptions.useSeconds || 0 : 0 );
var secondIterations:int = int( interval );
var milliRate:int = int(millisecondRate / frameRate);
var millisecondIterations:int = (interval / milliRate) >= 1?int(interval / milliRate):1;
var iterations:int = (useSeconds > 0?secondIterations:millisecondIterations);
for (si = 0; si <= iterations; si++) {
v[si] = RPEase[realHow](si, start, ending, iterations, argsers[0], argsers[1]);
} return v;
}
public static function mergeArrays(a1:Array, a2:Array):Array {
for each(var value:* in a2) { a1[a1.length] = value; }
return a1;
}
}
}
/**
* Easing functions by Robert Penner.
* or there is also com.actiontad.gameUtils.RPEase
*/
class RPEase {
public static const easeOptions:Object = {
"Linear":true, "InLinear":true, "OutLinear":1, "InOutLinear":1, "InElastic":1,
"OutElastic":1, "InOutElastic":1, "InQuad":1, "OutQuad":1, "InOutQuad":1,
"InBounce":1, "InOutBounce":1, "OutBounce":1, "InCirc":1, "InBack":1, "OutBack":1, "InOutBack":1,
"InQuint":1, "OutQuint":1, "InOutQuint":1, "OutCirc":1, "InOutCirc":1,
"In":1, "Out":1, "InOut":1, "InSine":1, "OutSine":1, "InOutSine":1
};
//Back
public static function InBack (t:Number, b:Number, c:Number, d:Number, s:Number, ... args):Number {
//if (s == undefined) s = 1.70158;
return c*(t/=d)*t*((s+1)*t - s) + b;
}
public static function OutBack (t:Number, b:Number, c:Number, d:Number, s:Number, ... args):Number {
//if (s == undefined) s = 1.70158;
return c*((t=t/d-1)*t*((s+1)*t + s) + 1) + b;
}
public static function InOutBack (t:Number, b:Number, c:Number, d:Number, s:Number, ... args):Number {
//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;
}
//Bounce
public static function OutBounce (t:Number, b:Number, c:Number, d:Number, ... args):Number {
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;
}
}
public static function InBounce(t:Number, b:Number, c:Number, d:Number, ... args):Number {
return c - OutBounce (d-t, 0, c, d) + b;
}
public static function InOutBounce (t:Number, b:Number, c:Number, d:Number, ... args):Number {
if (t < d/2) return InBounce (t*2, 0, c, d) * .5 + b;
else return OutBounce (t*2-d, 0, c, d) * .5 + c*.5 + b;
}
//Circ
public static function InCirc (t:Number, b:Number, c:Number, d:Number, ... args):Number {
return -c * (Math.sqrt(1 - (t/=d)*t) - 1) + b;
}
public static function OutCirc (t:Number, b:Number, c:Number, d:Number, ... args):Number {
return c * Math.sqrt(1 - (t=t/d-1)*t) + b;
}
public static function InOutCirc (t:Number, b:Number, c:Number, d:Number, ... args):Number {
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;
}
//Cubic
public static function In (t:Number, b:Number, c:Number, d:Number, ... args):Number {
return c*(t/=d)*t*t + b;
}
public static function Out (t:Number, b:Number, c:Number, d:Number, ... args):Number {
return c*((t=t/d-1)*t*t + 1) + b;
}
public static function InOut (t:Number, b:Number, c:Number, d:Number, ... args):Number {
if ((t/=d/2) < 1) return c/2*t*t*t + b;
return c/2*((t-=2)*t*t + 2) + b;
}
//Elastic
public static function InElastic (t:Number, b:Number, c:Number, d:Number, a:Number, p:Number, ... args):Number {
if (t==0) return b; if ((t/=d)==1) return b+c; if (!p) p=d*.3;
if (!a || a < Math.abs(c)) { a=c; var s:Number =p/4; }
else 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;
}
public static function OutElastic (t:Number, b:Number, c:Number, d:Number, a:Number, p:Number, ... args):Number {
if (t==0) return b; if ((t/=d)==1) return b+c; if (!p) p=d*.3;
if (!a || a < Math.abs(c)) { a=c; var s:Number = p/4; }
else 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);
}
public static function InOutElastic (t:Number, b:Number, c:Number, d:Number, a:Number, p:Number, ... args):Number {
if (t==0) return b; if ((t/=d/2)==2) return b+c; if (!p) p=d*(.3*1.5);
if (!a || a < Math.abs(c)) { a=c; var s:Number = p/4; }
else 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;
}
//Expo
public static function InExpo (t:Number, b:Number, c:Number, d:Number, ... args):Number {
return (t==0) ? b : c * Math.pow(2, 10 * (t/d - 1)) + b;
}
public static function OutExpo (t:Number, b:Number, c:Number, d:Number, ... args):Number {
return (t==d) ? b+c : c * (-Math.pow(2, -10 * t/d) + 1) + b;
}
public static function InOutExpo (t:Number, b:Number, c:Number, d:Number, ... args):Number {
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;
}
//Linear
public static function Linear (t:Number, b:Number, c:Number, d:Number, ... args):Number {
return c*t/d + b;
}
public static function InLinear (t:Number, b:Number, c:Number, d:Number, ... args):Number {
return c*t/d + b;
}
public static function OutLinear (t:Number, b:Number, c:Number, d:Number, ... args):Number {
return c*t/d + b;
}
public static function InOutLinear (t:Number, b:Number, c:Number, d:Number, ... args):Number {
return c*t/d + b;
}
//Quad
public static function InQuad (t:Number, b:Number, c:Number, d:Number, ... args):Number {
return c*(t/=d)*t + b;
}
public static function OutQuad (t:Number, b:Number, c:Number, d:Number, ... args):Number {
return -c *(t/=d)*(t-2) + b;
}
public static function InOutQuad (t:Number, b:Number, c:Number, d:Number, ... args):Number {
if ((t/=d/2) < 1) return c/2*t*t + b;
return -c/2 * ((--t)*(t-2) - 1) + b;
}
//Quart
public static function InQuart (t:Number, b:Number, c:Number, d:Number, ... args):Number {
return c*(t/=d)*t*t*t + b;
}
public static function OutQuart (t:Number, b:Number, c:Number, d:Number, ... args):Number {
return -c * ((t=t/d-1)*t*t*t - 1) + b;
}
public static function InOutQuart (t:Number, b:Number, c:Number, d:Number, ... args):Number {
if ((t/=d/2) < 1) return c/2*t*t*t*t + b;
return -c/2 * ((t-=2)*t*t*t - 2) + b;
}
//Quint
public static function InQuint (t:Number, b:Number, c:Number, d:Number, ... args):Number {
return c*(t/=d)*t*t*t*t + b;
}
public static function OutQuint (t:Number, b:Number, c:Number, d:Number, ... args):Number {
return c*((t=t/d-1)*t*t*t*t + 1) + b;
}
public static function InOutQuint (t:Number, b:Number, c:Number, d:Number, ... args):Number {
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;
}
//Sine
public static function InSine (t:Number, b:Number, c:Number, d:Number, ... args):Number {
return -c * Math.cos(t/d * (Math.PI/2)) + c + b;
}
public static function OutSine (t:Number, b:Number, c:Number, d:Number, ... args):Number {
return c * Math.sin(t/d * (Math.PI/2)) + b;
}
public static function InOutSine (t:Number, b:Number, c:Number, d:Number, ... args):Number {
return -c/2 * (Math.cos(Math.PI*t/d) - 1) + b;
}
//... args are to help easily account for/incorporate the few functions that take more than 4 args.
}