starling-framework

import IAnimatable from "./IAnimatable"; 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: * * * * <pre> * * var juggler:Juggler = Starling.juggler; * * </pre> * * * * 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 function 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. * * * * <pre> * * juggler.delayCall(object.removeFromParent, 1.0); * * juggler.delayCall(object.addChild, 2.0, theChild); * * juggler.delayCall(function():Void { rotation += 0.1; }, 3.0); * * </pre> * * * * @see Tween * * @see DelayedCall * */ export class Juggler implements IAnimatable { /** * Create an empty juggler. */ constructor(); /** * Adds an object to the juggler. * * * * @return Unique numeric identifier for the animation. This identifier may be used * * to remove the object via <code>removeByID()</code>. * */ add(object: IAnimatable): number; addWithID(object: IAnimatable, objectID: number): number; /** * Determines if an object has been added to the juggler. */ 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. * */ 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 <code>remove</code> method, * * you might accidentally remove an object that has changed its context. By using * * <code>removeByID</code> 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. * */ removeByID(objectID: number): number; /** * Removes all tweens with a certain target. */ removeTweens(target: any): void; /** * Removes all delayed and repeated calls with a certain callback. */ removeDelayedCalls(callback: Function): void; /** * Figures out if the juggler contains one or more tweens with a certain target. */ containsTweens(target: any): boolean; /** * Figures out if the juggler contains one or more delayed calls with a certain callback. */ containsDelayedCalls(callback: Function): boolean; /** * Removes all objects at once. */ purge(): void; /** * Delays the execution of a function until <code>delay</code> 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 <code>removeByID()</code>. * */ delayCall(call: Function, delay: number, args?: Array<any>): number; /** * Runs a function 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 <code>removeByID()</code>. * */ repeatCall(call: Function, interval: number, repeatCount?: number, args?: Array<any>): number; /** * Utilizes a tween to animate the target object over <code>time</code> 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: * * * * <pre> * * juggler.tween(object, 2.0, { * * transition: Transitions.EASE_IN_OUT, * * delay: 20, // -> tween.delay = 20 * * x: 50 // -> tween.animate("x", 50) * * }); * * </pre> * * * * To cancel the tween, call 'Juggler.removeTweens' with the same target, or pass * * the returned ID to 'Juggler.removeByID()'. * * * * Note that some property types may be animated in a special way: * * <ul> * * <li>If the property contains the string <code>color</code> or <code>Color</code>, * * it will be treated as an unsigned integer with a color value * * (e.g. <code>0xff0000</code> for red). Each color channel will be animated * * individually.</li> * * <li>The same happens if you append the string <code>#rgb</code> to the name.</li> * * <li>If you append <code>#rad</code>, the property is treated as an angle in radians, * * making sure it always uses the shortest possible arc for the rotation.</li> * * <li>The string <code>#deg</code> does the same for angles in degrees.</li> * * </ul> * */ tween(target: any, time: number, properties: any): number; /** * Advances all objects by a certain time (in seconds). */ advanceTime(time: number): void; /** * The total life time of the juggler (in seconds). */ 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 */ get timeScale(): number; set timeScale(value: number) } } export default starling.animation.Juggler;