excalibur 0.25.0 → 0.25.1

package/build/esm/Actions/Action/Blink.d.ts

@@ -0,0 +1,17 @@
+import { Entity } from '../../EntityComponentSystem/Entity';
+import { Action } from '../Action';
+export declare class Blink implements Action {
+    private _graphics;
+    private _timeVisible;
+    private _timeNotVisible;
+    private _elapsedTime;
+    private _totalTime;
+    private _duration;
+    private _stopped;
+    private _started;
+    constructor(entity: Entity, timeVisible: number, timeNotVisible: number, numBlinks?: number);
+    update(delta: number): void;
+    isComplete(): boolean;
+    stop(): void;
+    reset(): void;
+}

package/build/esm/Actions/Action/CallMethod.d.ts

@@ -0,0 +1,10 @@
+import { Action } from '../Action';
+export declare class CallMethod implements Action {
+    private _method;
+    private _hasBeenCalled;
+    constructor(method: () => any);
+    update(_delta: number): void;
+    isComplete(): boolean;
+    reset(): void;
+    stop(): void;
+}

package/build/esm/Actions/Action/Delay.d.ts

@@ -0,0 +1,12 @@
+import { Action } from '../Action';
+export declare class Delay implements Action {
+    private _elapsedTime;
+    private _delay;
+    private _started;
+    private _stopped;
+    constructor(delay: number);
+    update(delta: number): void;
+    isComplete(): boolean;
+    stop(): void;
+    reset(): void;
+}

package/build/esm/Actions/Action/Die.d.ts

@@ -0,0 +1,11 @@
+import { Entity } from '../../EntityComponentSystem/Entity';
+import { Action } from '../Action';
+export declare class Die implements Action {
+    private _entity;
+    private _stopped;
+    constructor(entity: Entity);
+    update(_delta: number): void;
+    isComplete(): boolean;
+    stop(): void;
+    reset(): void;
+}

package/build/esm/Actions/Action/EaseTo.d.ts

@@ -0,0 +1,21 @@
+import { Entity } from '../../EntityComponentSystem/Entity';
+import { Actor } from '../../Actor';
+import { Action } from '../Action';
+export declare class EaseTo implements Action {
+    easingFcn: (currentTime: number, startValue: number, endValue: number, duration: number) => number;
+    private _tx;
+    private _motion;
+    private _currentLerpTime;
+    private _lerpDuration;
+    private _lerpStart;
+    private _lerpEnd;
+    private _initialized;
+    private _stopped;
+    private _distance;
+    constructor(entity: Entity, x: number, y: number, duration: number, easingFcn: (currentTime: number, startValue: number, endValue: number, duration: number) => number);
+    private _initialize;
+    update(delta: number): void;
+    isComplete(actor: Actor): boolean;
+    reset(): void;
+    stop(): void;
+}

package/build/esm/Actions/Action/Fade.d.ts

@@ -0,0 +1,17 @@
+import { Entity } from '../../EntityComponentSystem/Entity';
+import { Action } from '../Action';
+export declare class Fade implements Action {
+    private _graphics;
+    x: number;
+    y: number;
+    private _endOpacity;
+    private _speed;
+    private _multiplier;
+    private _started;
+    private _stopped;
+    constructor(entity: Entity, endOpacity: number, speed: number);
+    update(delta: number): void;
+    isComplete(): boolean;
+    stop(): void;
+    reset(): void;
+}

package/build/esm/Actions/Action/Follow.d.ts

@@ -0,0 +1,23 @@
+import { Entity } from '../../EntityComponentSystem/Entity';
+import { Action } from '../Action';
+export declare class Follow implements Action {
+    private _tx;
+    private _motion;
+    private _followTx;
+    private _followMotion;
+    x: number;
+    y: number;
+    private _current;
+    private _end;
+    private _dir;
+    private _speed;
+    private _maximumDistance;
+    private _distanceBetween;
+    private _started;
+    private _stopped;
+    constructor(entity: Entity, entityToFollow: Entity, followDistance?: number);
+    update(_delta: number): void;
+    stop(): void;
+    isComplete(): boolean;
+    reset(): void;
+}

package/build/esm/Actions/Action/Meet.d.ts

@@ -0,0 +1,23 @@
+import { Entity } from '../../EntityComponentSystem/Entity';
+import { Action } from '../Action';
+export declare class Meet implements Action {
+    private _tx;
+    private _motion;
+    private _meetTx;
+    private _meetMotion;
+    x: number;
+    y: number;
+    private _current;
+    private _end;
+    private _dir;
+    private _speed;
+    private _distanceBetween;
+    private _started;
+    private _stopped;
+    private _speedWasSpecified;
+    constructor(actor: Entity, actorToMeet: Entity, speed?: number);
+    update(_delta: number): void;
+    isComplete(): boolean;
+    stop(): void;
+    reset(): void;
+}

package/build/esm/Actions/Action/MoveBy.d.ts

@@ -0,0 +1,22 @@
+import { Entity } from '../../EntityComponentSystem/Entity';
+import { Action } from '../Action';
+export declare class MoveBy implements Action {
+    private _tx;
+    private _motion;
+    private _entity;
+    x: number;
+    y: number;
+    private _distance;
+    private _speed;
+    private _start;
+    private _offset;
+    private _end;
+    private _dir;
+    private _started;
+    private _stopped;
+    constructor(entity: Entity, offsetX: number, offsetY: number, speed: number);
+    update(_delta: number): void;
+    isComplete(entity: Entity): boolean;
+    stop(): void;
+    reset(): void;
+}

package/build/esm/Actions/Action/MoveTo.d.ts

@@ -0,0 +1,21 @@
+import { Entity } from '../../EntityComponentSystem/Entity';
+import { Action } from '../Action';
+export declare class MoveTo implements Action {
+    entity: Entity;
+    private _tx;
+    private _motion;
+    x: number;
+    y: number;
+    private _start;
+    private _end;
+    private _dir;
+    private _speed;
+    private _distance;
+    private _started;
+    private _stopped;
+    constructor(entity: Entity, destx: number, desty: number, speed: number);
+    update(_delta: number): void;
+    isComplete(entity: Entity): boolean;
+    stop(): void;
+    reset(): void;
+}

package/build/esm/Actions/Action/Repeat.d.ts

@@ -0,0 +1,16 @@
+import { Entity } from '../../EntityComponentSystem/Entity';
+import { Action } from '../Action';
+import { ActionContext } from '../ActionContext';
+export declare class Repeat implements Action {
+    private _actionQueue;
+    private _repeat;
+    private _originalRepeat;
+    private _stopped;
+    private _repeatContext;
+    private _repeatBuilder;
+    constructor(entity: Entity, repeatBuilder: (repeatContext: ActionContext) => any, repeat: number);
+    update(delta: number): void;
+    isComplete(): boolean;
+    stop(): void;
+    reset(): void;
+}

package/build/esm/Actions/Action/RepeatForever.d.ts

@@ -0,0 +1,20 @@
+import { Entity } from '../../EntityComponentSystem/Entity';
+import { Action } from '../Action';
+import { ActionContext } from '../ActionContext';
+/**
+ * RepeatForever Action implementation, it is recommended you use the fluent action
+ * context API.
+ *
+ *
+ */
+export declare class RepeatForever implements Action {
+    private _actionQueue;
+    private _stopped;
+    private _repeatContext;
+    private _repeatBuilder;
+    constructor(entity: Entity, repeatBuilder: (repeatContext: ActionContext) => any);
+    update(delta: number): void;
+    isComplete(): boolean;
+    stop(): void;
+    reset(): void;
+}

package/build/esm/Actions/Action/RotateBy.d.ts

@@ -0,0 +1,27 @@
+import { Action } from '../Action';
+import { RotationType } from '../RotationType';
+import { Entity } from '../../EntityComponentSystem/Entity';
+export declare class RotateBy implements Action {
+    private _tx;
+    private _motion;
+    x: number;
+    y: number;
+    private _start;
+    private _end;
+    private _speed;
+    private _offset;
+    private _rotationType;
+    private _direction;
+    private _distance;
+    private _shortDistance;
+    private _longDistance;
+    private _shortestPathIsPositive;
+    private _currentNonCannonAngle;
+    private _started;
+    private _stopped;
+    constructor(entity: Entity, angleRadiansOffset: number, speed: number, rotationType?: RotationType);
+    update(_delta: number): void;
+    isComplete(): boolean;
+    stop(): void;
+    reset(): void;
+}

package/build/esm/Actions/Action/RotateTo.d.ts

@@ -0,0 +1,26 @@
+import { Action } from '../Action';
+import { RotationType } from '../RotationType';
+import { Entity } from '../../EntityComponentSystem/Entity';
+export declare class RotateTo implements Action {
+    private _tx;
+    private _motion;
+    x: number;
+    y: number;
+    private _start;
+    private _end;
+    private _speed;
+    private _rotationType;
+    private _direction;
+    private _distance;
+    private _shortDistance;
+    private _longDistance;
+    private _shortestPathIsPositive;
+    private _currentNonCannonAngle;
+    private _started;
+    private _stopped;
+    constructor(entity: Entity, angleRadians: number, speed: number, rotationType?: RotationType);
+    update(_delta: number): void;
+    isComplete(): boolean;
+    stop(): void;
+    reset(): void;
+}

package/build/esm/Actions/Action/ScaleBy.d.ts

@@ -0,0 +1,24 @@
+import { Entity } from '../../EntityComponentSystem/Entity';
+import { Action } from '../Action';
+export declare class ScaleBy implements Action {
+    private _tx;
+    private _motion;
+    x: number;
+    y: number;
+    private _startScale;
+    private _endScale;
+    private _offset;
+    private _distanceX;
+    private _distanceY;
+    private _directionX;
+    private _directionY;
+    private _started;
+    private _stopped;
+    private _speedX;
+    private _speedY;
+    constructor(entity: Entity, scaleOffsetX: number, scaleOffsetY: number, speed: number);
+    update(_delta: number): void;
+    isComplete(): boolean;
+    stop(): void;
+    reset(): void;
+}

package/build/esm/Actions/Action/ScaleTo.d.ts

@@ -0,0 +1,23 @@
+import { Action } from '../Action';
+import { Entity } from '../../EntityComponentSystem/Entity';
+export declare class ScaleTo implements Action {
+    private _tx;
+    private _motion;
+    x: number;
+    y: number;
+    private _startX;
+    private _startY;
+    private _endX;
+    private _endY;
+    private _speedX;
+    private _speedY;
+    private _distanceX;
+    private _distanceY;
+    private _started;
+    private _stopped;
+    constructor(entity: Entity, scaleX: number, scaleY: number, speedX: number, speedY: number);
+    update(_delta: number): void;
+    isComplete(): boolean;
+    stop(): void;
+    reset(): void;
+}

package/build/esm/Actions/Action.d.ts

@@ -0,0 +1,10 @@
+import { Entity } from '../EntityComponentSystem/Entity';
+/**
+ * Used for implementing actions for the [[ActionContext|Action API]].
+ */
+export interface Action {
+    update(delta: number): void;
+    isComplete(entity: Entity): boolean;
+    reset(): void;
+    stop(): void;
+}

package/build/esm/Actions/ActionContext.d.ts

@@ -0,0 +1,219 @@
+import { RotationType } from './RotationType';
+import { EasingFunction } from '../Util/EasingFunctions';
+import { ActionQueue } from './ActionQueue';
+import { Vector } from '../Math/vector';
+import { Entity } from '../EntityComponentSystem/Entity';
+/**
+ * The fluent Action API allows you to perform "actions" on
+ * [[Actor|Actors]] such as following, moving, rotating, and
+ * more. You can implement your own actions by implementing
+ * the [[Action]] interface.
+ */
+export declare class ActionContext {
+    private _entity;
+    private _queue;
+    constructor(entity: Entity);
+    getQueue(): ActionQueue;
+    update(elapsedMs: number): void;
+    /**
+     * Clears all queued actions from the Actor
+     */
+    clearActions(): void;
+    /**
+     * This method will move an actor to the specified `x` and `y` position over the
+     * specified duration using a given [[EasingFunctions]] and return back the actor. This
+     * method is part of the actor 'Action' fluent API allowing action chaining.
+     * @param pos       The x,y vector location to move the actor to
+     * @param duration  The time it should take the actor to move to the new location in milliseconds
+     * @param easingFcn Use [[EasingFunctions]] or a custom function to use to calculate position, Default is [[EasingFunctions.Linear]]
+     */
+    easeTo(pos: Vector, duration: number, easingFcn?: EasingFunction): ActionContext;
+    /**
+     * This method will move an actor to the specified `x` and `y` position over the
+     * specified duration using a given [[EasingFunctions]] and return back the actor. This
+     * method is part of the actor 'Action' fluent API allowing action chaining.
+     * @param x         The x location to move the actor to
+     * @param y         The y location to move the actor to
+     * @param duration  The time it should take the actor to move to the new location in milliseconds
+     * @param easingFcn Use [[EasingFunctions]] or a custom function to use to calculate position, Default is [[EasingFunctions.Linear]]
+     */
+    easeTo(x: number, y: number, duration: number, easingFcn?: EasingFunction): ActionContext;
+    /**
+     * This method will move an actor to the specified x and y position at the
+     * speed specified (in pixels per second) and return back the actor. This
+     * method is part of the actor 'Action' fluent API allowing action chaining.
+     * @param pos    The x,y vector location to move the actor to
+     * @param speed  The speed in pixels per second to move
+     */
+    moveTo(pos: Vector, speed: number): ActionContext;
+    /**
+     * This method will move an actor to the specified x and y position at the
+     * speed specified (in pixels per second) and return back the actor. This
+     * method is part of the actor 'Action' fluent API allowing action chaining.
+     * @param x      The x location to move the actor to
+     * @param y      The y location to move the actor to
+     * @param speed  The speed in pixels per second to move
+     */
+    moveTo(x: number, y: number, speed: number): ActionContext;
+    /**
+     * This method will move an actor by the specified x offset and y offset from its current position, at a certain speed.
+     * This method is part of the actor 'Action' fluent API allowing action chaining.
+     * @param xOffset     The x offset to apply to this actor
+     * @param yOffset     The y location to move the actor to
+     * @param speed  The speed in pixels per second the actor should move
+     */
+    moveBy(offset: Vector, speed: number): ActionContext;
+    moveBy(xOffset: number, yOffset: number, speed: number): ActionContext;
+    /**
+     * This method will rotate an actor to the specified angle at the speed
+     * specified (in radians per second) and return back the actor. This
+     * method is part of the actor 'Action' fluent API allowing action chaining.
+     * @param angleRadians  The angle to rotate to in radians
+     * @param speed         The angular velocity of the rotation specified in radians per second
+     * @param rotationType  The [[RotationType]] to use for this rotation
+     */
+    rotateTo(angleRadians: number, speed: number, rotationType?: RotationType): ActionContext;
+    /**
+     * This method will rotate an actor by the specified angle offset, from it's current rotation given a certain speed
+     * in radians/sec and return back the actor. This method is part
+     * of the actor 'Action' fluent API allowing action chaining.
+     * @param angleRadiansOffset  The angle to rotate to in radians relative to the current rotation
+     * @param speed          The speed in radians/sec the actor should rotate at
+     * @param rotationType  The [[RotationType]] to use for this rotation, default is shortest path
+     */
+    rotateBy(angleRadiansOffset: number, speed: number, rotationType?: RotationType): ActionContext;
+    /**
+     * This method will scale an actor to the specified size at the speed
+     * specified (in magnitude increase per second) and return back the
+     * actor. This method is part of the actor 'Action' fluent API allowing
+     * action chaining.
+     * @param size    The scale to adjust the actor to over time
+     * @param speed   The speed of scaling specified in magnitude increase per second
+     */
+    scaleTo(size: Vector, speed: Vector): ActionContext;
+    /**
+     * This method will scale an actor to the specified size at the speed
+     * specified (in magnitude increase per second) and return back the
+     * actor. This method is part of the actor 'Action' fluent API allowing
+     * action chaining.
+     * @param sizeX   The scaling factor to apply on X axis
+     * @param sizeY   The scaling factor to apply on Y axis
+     * @param speedX  The speed of scaling specified in magnitude increase per second on X axis
+     * @param speedY  The speed of scaling specified in magnitude increase per second on Y axis
+     */
+    scaleTo(sizeX: number, sizeY: number, speedX: number, speedY: number): ActionContext;
+    /**
+     * This method will scale an actor by an amount relative to the current scale at a certain speed in scale units/sec
+     * and return back the actor. This method is part of the
+     * actor 'Action' fluent API allowing action chaining.
+     * @param offset   The scaling factor to apply to the actor
+     * @param speed    The speed to scale at in scale units/sec
+     */
+    scaleBy(offset: Vector, speed: number): ActionContext;
+    /**
+     * This method will scale an actor by an amount relative to the current scale at a certain speed in scale units/sec
+     * and return back the actor. This method is part of the
+     * actor 'Action' fluent API allowing action chaining.
+     * @param sizeOffsetX   The scaling factor to apply on X axis
+     * @param sizeOffsetY   The scaling factor to apply on Y axis
+     * @param speed    The speed to scale at in scale units/sec
+     */
+    scaleBy(sizeOffsetX: number, sizeOffsetY: number, speed: number): ActionContext;
+    /**
+     * This method will cause an actor to blink (become visible and not
+     * visible). Optionally, you may specify the number of blinks. Specify the amount of time
+     * the actor should be visible per blink, and the amount of time not visible.
+     * This method is part of the actor 'Action' fluent API allowing action chaining.
+     * @param timeVisible     The amount of time to stay visible per blink in milliseconds
+     * @param timeNotVisible  The amount of time to stay not visible per blink in milliseconds
+     * @param numBlinks       The number of times to blink
+     */
+    blink(timeVisible: number, timeNotVisible: number, numBlinks?: number): ActionContext;
+    /**
+     * This method will cause an actor's opacity to change from its current value
+     * to the provided value by a specified time (in milliseconds). This method is
+     * part of the actor 'Action' fluent API allowing action chaining.
+     * @param opacity  The ending opacity
+     * @param time     The time it should take to fade the actor (in milliseconds)
+     */
+    fade(opacity: number, time: number): ActionContext;
+    /**
+     * This method will delay the next action from executing for a certain
+     * amount of time (in milliseconds). This method is part of the actor
+     * 'Action' fluent API allowing action chaining.
+     * @param time  The amount of time to delay the next action in the queue from executing in milliseconds
+     */
+    delay(time: number): ActionContext;
+    /**
+     * This method will add an action to the queue that will remove the actor from the
+     * scene once it has completed its previous  Any actions on the
+     * action queue after this action will not be executed.
+     */
+    die(): ActionContext;
+    /**
+     * This method allows you to call an arbitrary method as the next action in the
+     * action queue. This is useful if you want to execute code in after a specific
+     * action, i.e An actor arrives at a destination after traversing a path
+     */
+    callMethod(method: () => any): ActionContext;
+    /**
+     * This method will cause the actor to repeat all of the actions built in
+     * the `repeatBuilder` callback. If the number of repeats
+     * is not specified it will repeat forever. This method is part of
+     * the actor 'Action' fluent API allowing action chaining
+     *
+     * ```typescript
+     * // Move up in a zig-zag by repeated moveBy's
+     * actor.actions.repeat(repeatCtx => {
+     *  repeatCtx.moveBy(10, 0, 10);
+     *  repeatCtx.moveBy(0, 10, 10);
+     * }, 5);
+     * ```
+     *
+     * @param repeatBuilder The builder to specify the repeatable list of actions
+     * @param times  The number of times to repeat all the previous actions in the action queue. If nothing is specified the actions
+     * will repeat forever
+     */
+    repeat(repeatBuilder: (repeatContext: ActionContext) => any, times?: number): ActionContext;
+    /**
+     * This method will cause the actor to repeat all of the actions built in
+     * the `repeatBuilder` callback. If the number of repeats
+     * is not specified it will repeat forever. This method is part of
+     * the actor 'Action' fluent API allowing action chaining
+     *
+     * ```typescript
+     * // Move up in a zig-zag by repeated moveBy's
+     * actor.actions.repeat(repeatCtx => {
+     *  repeatCtx.moveBy(10, 0, 10);
+     *  repeatCtx.moveBy(0, 10, 10);
+     * }, 5);
+     * ```
+     *
+     * @param repeatBuilder The builder to specify the repeatable list of actions
+     */
+    repeatForever(repeatBuilder: (repeatContext: ActionContext) => any): ActionContext;
+    /**
+     * This method will cause the entity to follow another at a specified distance
+     * @param entity           The entity to follow
+     * @param followDistance  The distance to maintain when following, if not specified the actor will follow at the current distance.
+     */
+    follow(entity: Entity, followDistance?: number): ActionContext;
+    /**
+     * This method will cause the entity to move towards another until they
+     * collide "meet" at a specified speed.
+     * @param entity  The entity to meet
+     * @param speed  The speed in pixels per second to move, if not specified it will match the speed of the other actor
+     */
+    meet(entity: Entity, speed?: number): ActionContext;
+    /**
+     * Returns a promise that resolves when the current action queue up to now
+     * is finished.
+     * @deprecated Use `toPromise()` will be removed in v0.26.0
+     */
+    asPromise(): Promise<void>;
+    /**
+     * Returns a promise that resolves when the current action queue up to now
+     * is finished.
+     */
+    toPromise(): Promise<void>;
+}

package/build/esm/Actions/ActionQueue.d.ts

@@ -0,0 +1,56 @@
+import { Entity } from '../EntityComponentSystem/Entity';
+import { Action } from './Action';
+/**
+ * Action Queues represent an ordered sequence of actions
+ *
+ * Action queues are part of the [[ActionContext|Action API]] and
+ * store the list of actions to be executed for an [[Actor]].
+ *
+ * Actors implement [[Actor.actions]] which can be manipulated by
+ * advanced users to adjust the actions currently being executed in the
+ * queue.
+ */
+export declare class ActionQueue {
+    private _entity;
+    private _actions;
+    private _currentAction;
+    private _completedActions;
+    constructor(entity: Entity);
+    /**
+     * Add an action to the sequence
+     * @param action
+     */
+    add(action: Action): void;
+    /**
+     * Remove an action by reference from the sequence
+     * @param action
+     */
+    remove(action: Action): void;
+    /**
+     * Removes all actions from this sequence
+     */
+    clearActions(): void;
+    /**
+     *
+     * @returns The total list of actions in this sequence complete or not
+     */
+    getActions(): Action[];
+    /**
+     *
+     * @returns `true` if there are more actions to process in the sequence
+     */
+    hasNext(): boolean;
+    /**
+     * @returns `true` if the current sequence of actions is done
+     */
+    isComplete(): boolean;
+    /**
+     * Resets the sequence of actions, this is used to restart a sequence from the beginning
+     */
+    reset(): void;
+    /**
+     * Update the queue which updates actions and handles completing actions
+     * @param elapsedMs
+     */
+    update(elapsedMs: number): void;
+}

package/build/esm/Actions/Actionable.d.ts

@@ -0,0 +1,4 @@
+import { ActionContext } from './ActionContext';
+export interface Actionable {
+    actions: ActionContext;
+}