excalibur 0.25.0 → 0.25.1

package/build/dist/Actions/ActionsComponent.d.ts

@@ -0,0 +1,236 @@
+import { ActionContext } from './ActionContext';
+import { Component } from '../EntityComponentSystem/Component';
+import { Entity } from '../EntityComponentSystem/Entity';
+import { Actor } from '../Actor';
+import { MotionComponent } from '../EntityComponentSystem/Components/MotionComponent';
+import { TransformComponent } from '../EntityComponentSystem/Components/TransformComponent';
+import { Vector } from '../Math/vector';
+import { EasingFunction } from '../Util/EasingFunctions';
+import { ActionQueue } from './ActionQueue';
+import { RotationType } from './RotationType';
+export interface ActionContextMethods extends Pick<ActionContext, keyof ActionContext> {
+}
+export declare class ActionsComponent extends Component<'ex.actions'> implements ActionContextMethods {
+    readonly type = "ex.actions";
+    dependencies: (typeof TransformComponent | typeof MotionComponent)[];
+    private _ctx;
+    onAdd(entity: Entity): void;
+    onRemove(): void;
+    /**
+     * Returns the internal action queue
+     * @returns action queu
+     */
+    getQueue(): ActionQueue;
+    /**
+     * Updates the internal action context, performing action and moving through the internal queue
+     * @param elapsedMs
+     */
+    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 offset The (x, y) offset to apply to this actor
+     * @param speed  The speed in pixels per second the actor should move
+     */
+    moveBy(offset: Vector, 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(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: Actor, 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: Actor, 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/dist/Actions/ActionsSystem.d.ts

@@ -0,0 +1,9 @@
+import { Entity } from '../EntityComponentSystem';
+import { System, SystemType } from '../EntityComponentSystem/System';
+import { ActionsComponent } from './ActionsComponent';
+export declare class ActionsSystem extends System<ActionsComponent> {
+    readonly types: readonly ["ex.actions"];
+    systemType: SystemType;
+    priority: number;
+    update(entities: Entity[], delta: number): void;
+}

package/build/dist/Actions/Index.d.ts

@@ -17,3 +17,5 @@ export * from './Action/RotateBy';
 export * from './Action/RotateTo';
 export * from './Action/ScaleBy';
 export * from './Action/ScaleTo';
+export * from './ActionsComponent';
+export * from './ActionsSystem';

package/build/dist/Actor.d.ts

@@ -9,11 +9,9 @@ import { Drawable } from './Interfaces/Drawable';
 import { CanInitialize, CanUpdate, CanDraw, CanBeKilled } from './Interfaces/LifecycleEvents';
 import { Scene } from './Scene';
 import { Logger } from './Util/Log';
-import { ActionContext } from './Actions/ActionContext';
 import { Vector } from './Math/vector';
 import { BodyComponent } from './Collision/BodyComponent';
 import { Eventable } from './Interfaces/Evented';
-import { Actionable } from './Actions/Actionable';
 import * as Events from './Events';
 import { PointerEvents } from './Interfaces/PointerEventHandlers';
 import { CollisionType } from './Collision/CollisionType';
@@ -24,6 +22,7 @@ import { GraphicsComponent } from './Graphics/GraphicsComponent';
 import { ColliderComponent } from './Collision/ColliderComponent';
 import { Collider, CollisionGroup } from './Collision/Index';
 import { CapturePointerConfig } from './Input/CapturePointerConfig';
+import { ActionsComponent } from './Actions/ActionsComponent';
 /**
  * Type guard for checking if something is an Actor
  * @param x
@@ -117,7 +116,7 @@ export interface ActorArgs {
  * or interact with the current scene, must be an actor. An `Actor` **must**
  * be part of a [[Scene]] for it to be drawn to the screen.
  */
-export declare class Actor extends Entity implements Actionable, Eventable, PointerEvents, CanInitialize, CanUpdate, CanDraw, CanBeKilled {
+export declare class Actor extends Entity implements Eventable, PointerEvents, CanInitialize, CanUpdate, CanDraw, CanBeKilled {
     /**
      * Set defaults for all Actors
      */
@@ -142,9 +141,16 @@ export declare class Actor extends Entity implements Actionable, Eventable, Poin
      */
     get graphics(): GraphicsComponent;
     /**
-     * Access to the Actor's build in [[ColliderComponent]]
+     * Access to the Actor's built in [[ColliderComponent]]
      */
     get collider(): ColliderComponent;
+    /**
+     * Useful for quickly scripting actor behavior, like moving to a place, patroling back and forth, blinking, etc.
+     *
+     *  Access to the Actor's built in [[ActionsComponent]] which forwards to the
+     * [[ActionContext|Action context]] of the actor.
+     */
+    get actions(): ActionsComponent;
     /**
      * Gets the position vector of the actor in pixels
      */
@@ -244,10 +250,6 @@ export declare class Actor extends Entity implements Actionable, Eventable, Poin
      */
     get opacity(): number;
     set opacity(opacity: number);
-    /**
-     * [[ActionContext|Action context]] of the actor. Useful for scripting actor behavior.
-     */
-    actions: ActionContext;
     /**
      * Convenience reference to the global logger
      */

package/build/dist/Engine.d.ts

@@ -550,13 +550,18 @@ export declare class Engine extends Class implements CanInitialize, CanUpdate, C
      * Toggle Excalibur debugging functionality.
      */
     toggleDebug(): boolean;
+    private _loadingComplete;
+    /**
+     * Returns true when loading is totally complete and the player has clicked start
+     */
+    get loadingComplete(): boolean;
     /**
      * Starts the internal game loop for Excalibur after loading
      * any provided assets.
      * @param loader  Optional [[Loader]] to use to load resources. The default loader is [[Loader]], override to provide your own
      * custom loader.
      */
-    start(loader?: Loader): Promise<any>;
+    start(loader?: Loader): Promise<void>;
     static createMainLoop(game: Engine, raf: (func: Function) => number, nowFn: () => number): () => void;
     /**
      * Stops Excalibur's main loop, useful for pausing the game.

package/build/dist/EntityComponentSystem/EntityManager.d.ts

@@ -13,6 +13,7 @@ export declare class EntityManager<ContextType = any> implements Observer<Remove
      * @param _context
      */
     updateEntities(_context: ContextType, elapsed: number): void;
+    findEntitiesForRemoval(): void;
     /**
      * EntityManager observes changes on entities
      * @param message

package/build/dist/Graphics/Animation.d.ts

@@ -11,6 +11,16 @@ export interface HasTick {
      */
     tick(elapsedMilliseconds: number, idempotencyToken?: number): void;
 }
+export declare enum AnimationDirection {
+    /**
+     * Animation is playing forwards
+     */
+    Forward = "forward",
+    /**
+     * Animation is play backwards
+     */
+    Backward = "backward"
+}
 export declare enum AnimationStrategy {
     /**
      * Animation ends without displaying anything
@@ -50,10 +60,18 @@ export interface AnimationOptions {
      * List of frames in the order you wish to play them
      */
     frames: Frame[];
+    /**
+     * Optionally reverse the direction of play
+     */
+    reverse?: boolean;
     /**
      * Optionally specify a default frame duration in ms (Default is 1000)
      */
     frameDuration?: number;
+    /**
+     * Optionally specify a total duration of the animation in ms to calculate each frame's duration
+     */
+    totalDuration?: number;
     /**
      * Optionally specify the [[AnimationStrategy]] for the Animation
      */
@@ -110,15 +128,61 @@ export declare class Animation extends Graphic implements HasTick {
      * @returns LegacyDrawing.Animation
      */
     static toLegacyAnimation(engine: Engine, animation: Animation): LegacyDrawing.Animation;
+    /**
+     * Returns the current Frame of the animation
+     */
     get currentFrame(): Frame | null;
+    /**
+     * Returns the current frame index of the animation
+     */
+    get currentFrameIndex(): number;
+    /**
+     * Returns `true` if the animation is playing
+     */
     get isPlaying(): boolean;
+    private _reversed;
+    /**
+     * Reverses the play direction of the Animation, this preserves the current frame
+     */
+    reverse(): void;
+    /**
+     * Returns the current play direction of the animation
+     */
+    get direction(): AnimationDirection;
+    /**
+     * Plays or resumes the animation from the current frame
+     */
     play(): void;
+    /**
+     * Pauses the animation on the current frame
+     */
     pause(): void;
+    /**
+     * Reset the animation back to the beginning, including if the animation were done
+     */
     reset(): void;
+    /**
+     * Returns `true` if the animation can end
+     */
     get canFinish(): boolean;
+    /**
+     * Returns `true` if the animation is done, for looping type animations
+     * `ex.AnimationStrategy.PingPong` and `ex.AnimationStrategy.Loop` this will always return `false`
+     *
+     * See the `ex.Animation.canFinish()` method to know if an animation type can end
+     */
     get done(): boolean;
+    /**
+     * Jump the animation immediately to a specific frame if it exists
+     * @param frameNumber
+     */
     goToFrame(frameNumber: number): void;
     private _nextFrame;
+    /**
+     * Called internally by Excalibur to update the state of the animation potential update the current frame
+     * @param elapsedMilliseconds Milliseconds elapsed
+     * @param idempotencyToken Prevents double ticking in a frame by passing a unique token to the frame
+     */
     tick(elapsedMilliseconds: number, idempotencyToken?: number): void;
     private _updateDimensions;
     protected _drawImage(ctx: ExcaliburGraphicsContext, x: number, y: number): void;

package/build/dist/Graphics/Context/ExcaliburGraphicsContext.d.ts

@@ -75,7 +75,7 @@ export interface ExcaliburGraphicsContext {
      */
     resetTransform(): void;
     /**
-     * Update the context with the curren tviewport dimensions (used in resizing)
+     * Update the context with the current viewport dimensions (used in resizing)
      */
     updateViewport(): void;
     /**

package/build/dist/Graphics/Context/ExcaliburGraphicsContextWebGL.d.ts

@@ -7,6 +7,7 @@ import { StateStack } from './state-stack';
 import { LineRenderer } from './line-renderer';
 import { ImageRenderer } from './image-renderer';
 import { PointRenderer } from './point-renderer';
+import { ScreenDimension } from '../../Screen';
 declare class ExcaliburGraphicsContextWebGLDebug implements DebugDraw {
     private _webglCtx;
     private _debugText;
@@ -79,6 +80,11 @@ export declare class ExcaliburGraphicsContextWebGL implements ExcaliburGraphicsC
     set opacity(value: number);
     get width(): number;
     get height(): number;
+    /**
+     * Checks the underlying webgl implementation if the requested internal resolution is supported
+     * @param dim
+     */
+    checkIfResolutionSupported(dim: ScreenDimension): boolean;
     constructor(options: ExcaliburGraphicsContextOptions);
     private _init;
     resetTransform(): void;

package/build/dist/Graphics/GraphicsComponent.d.ts

@@ -110,6 +110,7 @@ export declare class GraphicsLayer {
      */
     get offset(): Vector;
     set offset(value: Vector);
+    get currentKeys(): string;
 }
 export declare class GraphicsLayers {
     private _component;
@@ -127,6 +128,7 @@ export declare class GraphicsLayers {
      * Retrieve all layers
      */
     get(): readonly GraphicsLayer[];
+    currentKeys(): string[];
     has(name: string): boolean;
     private _maybeAddLayer;
     private _getLayer;

package/build/dist/Loader.css

@@ -16,6 +16,7 @@ button#excalibur-play {
   color: #ffffff;
   font-family: sans-serif;
   font-size: 2rem;
+  white-space: nowrap;
   line-height: 1;
   cursor: pointer;
   text-align: center;

package/build/dist/Loader.d.ts

@@ -164,6 +164,7 @@ export declare class Loader extends Class implements Loadable<Loadable<any>[]> {
      * Returns the progess of the loader as a number between [0, 1] inclusive.
      */
     get progress(): number;
+    private _positionPlayButton;
     /**
      * Loader draw function. Draws the default Excalibur loading screen.
      * Override `logo`, `logoWidth`, `logoHeight` and `backgroundColor` properties

package/build/dist/Screen.d.ts

@@ -174,7 +174,10 @@ export declare class Screen {
     get scaledHeight(): number;
     setCurrentCamera(camera: Camera): void;
     pushResolutionAndViewport(): void;
+    peekViewport(): ScreenDimension;
+    peekResolution(): ScreenDimension;
     popResolutionAndViewport(): void;
+    private _alreadyWarned;
     applyResolutionAndViewport(): void;
     get antialiasing(): boolean;
     set antialiasing(isSmooth: boolean);