import IAnimatable from "./IAnimatable"; import Vector from "openfl/Vector"; declare namespace starling.animation { /** The Juggler takes objects that implement IAnimatable (like Tweens) and executes them. * *

A juggler is a simple object. It does no more than saving a list of objects implementing * "IAnimatable" and advancing their time if it is told to do so (by calling its own * "advanceTime"-method). When an animation is completed, it throws it away.

* *

There is a default juggler available at the Starling class:

* * 
	 *  juggler:Juggler = Starling.juggler;
	 *
* *

You can create juggler objects yourself, just as well. That way, you can group * your game into logical components that handle their animations independently. All you have * to do is call the "advanceTime" method on your custom juggler once per frame.

* *

Another handy feature of the juggler is the "delayCall"-method. Use it to * execute a at a later time. Different to conventional approaches, the method * will only be called when the juggler is advanced, giving you perfect control over the * call.

* * 
	 *  juggler.delayCall(object.removeFromParent, 1.0);
	 *  juggler.delayCall(object.addChild, 2.0, theChild);
	 *  juggler.delayCall(function():void { rotation += 0.1; }, 3.0);
	 *
* * @see Tween * @see DelayedCall */ export class Juggler implements IAnimatable { /** Create an empty juggler. */ public constructor(); /** Adds an object to the juggler. * * @return Unique numeric identifier for the animation. This identifier may be used * to remove the object via removeByID(). */ public add(object:IAnimatable):number; public addWithID(object:IAnimatable, objectID:number):number; /** Determines if an object has been added to the juggler. */ public contains(object:IAnimatable):boolean; /** Removes an object from the juggler. * * @return The (now meaningless) unique numeric identifier for the animation, or zero * if the object was not found. */ public remove(object:IAnimatable):number; /** Removes an object from the juggler, identified by the unique numeric identifier you * received when adding it. * *

It's not uncommon that an animatable object is added to a juggler repeatedly, * e.g. when using an object-pool. Thus, when using the remove method, * you might accidentally remove an object that has changed its context. By using * removeByID instead, you can be sure to avoid that, since the objectID * will always be unique.

* * @return if successful, the passed objectID; if the object was not found, zero. */ public removeByID(objectID:number):number; /** Removes all tweens with a certain target. */ public removeTweens(target:any):void; /** Removes all delayed and repeated calls with a certain callback. */ public removeDelayedCalls(callback:Function):void; /** Figures out if the juggler contains one or more tweens with a certain target. */ public containsTweens(target:any):boolean; /** Figures out if the juggler contains one or more delayed calls with a certain callback. */ public containsDelayedCalls(callback:Function):boolean; /** Removes all objects at once. */ public purge():void; /** Delays the execution of a until delay seconds have passed. * This method provides a convenient alternative for creating and adding a DelayedCall * manually. * * @return Unique numeric identifier for the delayed call. This identifier may be used * to remove the object via removeByID(). */ public delayCall(call:Function, delay:number, args?:Array):number; /** Runs a at a specified interval (in seconds). A 'repeatCount' of zero * means that it runs indefinitely. * * @return Unique numeric identifier for the delayed call. This identifier may be used * to remove the object via removeByID(). */ public repeatCall(call:Function, interval:number, repeatCount?:number, args?:Array):number; /** Utilizes a tween to animate the target object over time seconds. Internally, * this method uses a tween instance (taken from an object pool) that is added to the * juggler right away. This method provides a convenient alternative for creating * and adding a tween manually. * *

Fill 'properties' with key-value pairs that describe both the * tween and the animation target. Here is an example:

* * 
		 *  juggler.tween(object, 2.0, {
		 *      transition: Transitions.EASE_IN_OUT,
		 *      delay: 20, // -> tween.delay = 20
		 *      x: 50      // -> tween.animate("x", 50)
		 *  });
		 *
* *

To cancel the tween, call 'Juggler.removeTweens' with the same target, or pass * the returned 'IAnimatable' instance to 'Juggler.remove()'. Do not use the returned * IAnimatable otherwise; it is taken from a pool and will be reused.

* *

Note that some property types may be animated in a special way:

* */ public tween(target:any, time:number, properties:any):number; /** Advances all objects by a certain time (in seconds). */ public advanceTime(time:number):void; /** The total life time of the juggler (in seconds). */ public readonly elapsedTime:number; protected get_elapsedTime():number; /** The scale at which the time is passing. This can be used for slow motion or time laps * effects. Values below '1' will make all animations run slower, values above '1' faster. * @default 1.0 */ public timeScale:number; protected get_timeScale():number; protected set_timeScale(value:number):number; /** The actual vector that contains all objects that are currently being animated. */ protected readonly objects:Vector; protected get_objects():Vector; } } export default starling.animation.Juggler;