excalibur 0.25.1 → 0.25.2

package/build/dist/Collision/ColliderComponent.d.ts

@@ -12,7 +12,7 @@ import { PolygonCollider } from './Colliders/PolygonCollider';
 import { EdgeCollider } from './Colliders/EdgeCollider';
 export declare class ColliderComponent extends Component<'ex.collider'> {
     readonly type = "ex.collider";
-    events: EventDispatcher<this>;
+    events: EventDispatcher<any>;
     /**
      * Observable that notifies when a collider is added to the body
      */
@@ -25,7 +25,6 @@ export declare class ColliderComponent extends Component<'ex.collider'> {
     private _collider;
     /**
      * Get the current collider geometry
-     * @returns
      */
     get(): Collider;
     /**
@@ -53,7 +52,6 @@ export declare class ColliderComponent extends Component<'ex.collider'> {
     /**
      * Collide component with another
      * @param other
-     * @returns
      */
     collide(other: ColliderComponent): CollisionContact[];
     onAdd(entity: Entity): void;
@@ -92,7 +90,6 @@ export declare class ColliderComponent extends Component<'ex.collider'> {
     /**
      * Setups up a [[CompositeCollider]] which can define any arbitrary set of excalibur colliders
      * @param colliders
-     * @returns
      */
     useCompositeCollider(colliders: Collider[]): CompositeCollider;
 }

package/build/dist/Collision/Colliders/CircleCollider.d.ts

@@ -27,10 +27,15 @@ export declare class CircleCollider extends Collider {
      */
     offset: Vector;
     get worldPos(): Vector;
+    private _naturalRadius;
     /**
-     * This is the radius of the circle
+     * Get the radius of the circle
      */
-    radius: number;
+    get radius(): number;
+    /**
+     * Set the radius of the circle
+     */
+    set radius(val: number);
     private _transform;
     constructor(options: CircleColliderOptions);
     /**
@@ -86,7 +91,18 @@ export declare class CircleCollider extends Collider {
      * Project the circle along a specified axis
      */
     project(axis: Vector): Projection;
+    /**
+     * @deprecated signature will change in v0.26.0
+     * @param ctx
+     * @param color
+     * @param pos
+     */
     draw(ctx: CanvasRenderingContext2D, color?: Color, pos?: Vector): void;
     debug(ex: ExcaliburGraphicsContext, color: Color): void;
+    /**
+     * @deprecated signature will change in v0.26.0
+     * @param ctx
+     * @param color
+     */
     debugDraw(ctx: CanvasRenderingContext2D, color?: Color): void;
 }

package/build/dist/Collision/Colliders/EdgeCollider.d.ts

@@ -18,7 +18,7 @@ export interface EdgeColliderOptions {
      */
     end: Vector;
     /**
-     * Optionall specify an offset
+     * Optionally specify an offset
      */
     offset?: Vector;
 }

package/build/dist/Collision/Colliders/SeparatingAxis.d.ts

@@ -16,11 +16,11 @@ export interface SeparationInfo {
      */
     separation: number;
     /**
-     * Axis of separation from the collider's perpective
+     * Axis of separation from the collider's perspective
      */
     axis: Vector;
     /**
-     * Side of separation (reference) from the collider's perpsective
+     * Side of separation (reference) from the collider's perspective
      */
     side?: Line;
     /**

package/build/dist/Collision/Detection/DynamicTreeCollisionProcessor.d.ts

@@ -5,12 +5,12 @@ import { Collider } from '../Colliders/Collider';
 import { CollisionContact } from '../Detection/CollisionContact';
 import { ExcaliburGraphicsContext } from '../..';
 /**
- * Responsible for performing the collision broadphase (locating potential colllisions) and
+ * Responsible for performing the collision broadphase (locating potential collisions) and
  * the narrowphase (actual collision contacts)
  */
 export declare class DynamicTreeCollisionProcessor implements CollisionProcessor {
     private _dynamicCollisionTree;
-    private _collisions;
+    private _pairs;
     private _collisionPairCache;
     private _colliders;
     getColliders(): readonly Collider[];
@@ -22,9 +22,9 @@ export declare class DynamicTreeCollisionProcessor implements CollisionProcessor
      * Untracks a physics body
      */
     untrack(target: Collider): void;
-    private _shouldGenerateCollisionPair;
+    private _pairExists;
     /**
-     * Detects potential collision pairs in a broadphase approach with the dynamic aabb tree strategy
+     * Detects potential collision pairs in a broadphase approach with the dynamic AABB tree strategy
      */
     broadphase(targets: Collider[], delta: number, stats?: FrameStats): Pair[];
     /**

package/build/dist/Collision/Detection/Pair.d.ts

@@ -9,6 +9,11 @@ export declare class Pair {
     colliderB: Collider;
     id: string;
     constructor(colliderA: Collider, colliderB: Collider);
+    /**
+     * Returns whether a it is allowed for 2 colliders in a Pair to collide
+     * @param colliderA
+     * @param colliderB
+     */
     static canCollide(colliderA: Collider, colliderB: Collider): boolean;
     /**
      * Returns whether or not it is possible for the pairs to collide
@@ -21,7 +26,6 @@ export declare class Pair {
     /**
      * Check if the collider is part of the pair
      * @param collider
-     * @returns
      */
     hasCollider(collider: Collider): boolean;
     /**

package/build/dist/Collision/Group/CollisionGroup.d.ts

@@ -85,7 +85,6 @@ export declare class CollisionGroup {
      * Combine collision groups with each other. The new group includes all of the previous groups.
      *
      * @param collisionGroups
-     * @returns
      */
     static combine(collisionGroups: CollisionGroup[]): CollisionGroup;
     /**

package/build/dist/Collision/MotionSystem.d.ts

@@ -7,5 +7,9 @@ export declare class MotionSystem extends System<TransformComponent | MotionComp
     systemType: SystemType;
     priority: number;
     update(_entities: Entity[], elapsedMs: number): void;
+    /**
+     * @deprecated signature will change in v0.26.0
+     * @param _ctx
+     */
     debugDraw(_ctx: CanvasRenderingContext2D): void;
 }

package/build/dist/Collision/Solver/ContactConstraintPoint.d.ts

@@ -13,7 +13,7 @@ export declare class ContactConstraintPoint {
      */
     update(): this;
     /**
-     * Returns the relative velocity betwen bodyA and bodyB
+     * Returns the relative velocity between bodyA and bodyB
      */
     getRelativeVelocity(): Vector;
     /**

package/build/dist/Collision/Solver/Solver.d.ts

@@ -31,7 +31,7 @@ export declare abstract class CollisionSolver {
      */
     abstract solveVelocity(contacts: CollisionContact[]): void;
     /**
-     * Solve position adjust the position of collders so that they are not overlapping
+     * Solve position adjust the position of colliders so that they are not overlapping
      * @param contacts
      * @inheritdoc
      */

package/build/dist/Debug/Debug.d.ts

@@ -2,6 +2,7 @@ import { DebugFlags, ColorBlindFlags } from './DebugFlags';
 import { Engine } from '../Engine';
 import { Color } from '../Color';
 import { CollisionContact } from '../Collision/Detection/CollisionContact';
+import { StandardClock, TestClock } from '..';
 /**
  * Debug stats containing current and previous frame statistics
  */
@@ -129,12 +130,27 @@ export interface GraphicsStatistics {
 export declare class Debug implements DebugFlags {
     private _engine;
     constructor(engine: Engine);
+    /**
+     * Switch the current excalibur clock with the [[TestClock]] and return
+     * it in the same running state.
+     *
+     * This is useful when you need to debug frame by frame.
+     */
+    useTestClock(): TestClock;
+    /**
+     * Switch the current excalibur clock with the [[StandardClock]] and
+     * return it in the same running state.
+     *
+     * This is useful when you need to switch back to normal mode after
+     * debugging.
+     */
+    useStandardClock(): StandardClock;
     /**
      * Performance statistics
      */
     stats: DebugStats;
     /**
-     * Correct or simulate color blindness using [[ColorBlindness]] post processor.
+     * Correct or simulate color blindness using [[ColorBlindnessPostProcessor]].
      * @warning Will reduce FPS.
      */
     colorBlindMode: ColorBlindFlags;
@@ -160,6 +176,7 @@ export declare class Debug implements DebugFlags {
     transform: {
         showAll: boolean;
         showPosition: boolean;
+        showPositionLabel: boolean;
         positionColor: Color;
         showScale: boolean;
         scaleColor: Color;

package/build/dist/Debug/DebugFlags.d.ts

@@ -1,11 +1,24 @@
+import { ColorBlindnessMode } from '../Graphics/PostProcessor/ColorBlindnessMode';
 import { Engine } from '../Engine';
-import { ColorBlindness } from '../PostProcessing/Index';
 export interface DebugFlags {
     colorBlindMode: ColorBlindFlags;
 }
 export declare class ColorBlindFlags {
     private _engine;
+    private _colorBlindPostProcessor;
     constructor(engine: Engine);
-    correct(colorBlindness: ColorBlindness): void;
-    simulate(colorBlindness: ColorBlindness): void;
+    /**
+     * Correct colors for a specified color blindness
+     * @param colorBlindness
+     */
+    correct(colorBlindness: ColorBlindnessMode): void;
+    /**
+     * Simulate colors for a specified color blindness
+     * @param colorBlindness
+     */
+    simulate(colorBlindness: ColorBlindnessMode): void;
+    /**
+     * Remove color blindness post processor
+     */
+    clear(): void;
 }

package/build/dist/Engine.d.ts

@@ -11,13 +11,13 @@ import { Loader } from './Loader';
 import { VisibleEvent, HiddenEvent, GameStartEvent, GameStopEvent, PreUpdateEvent, PostUpdateEvent, PreFrameEvent, PostFrameEvent, GameEvent, PreDrawEvent, PostDrawEvent } from './Events';
 import { Color } from './Color';
 import { Scene } from './Scene';
-import { PostProcessor } from './PostProcessing/PostProcessor';
 import { Debug, DebugStats } from './Debug/Debug';
 import { Class } from './Class';
 import * as Input from './Input/Index';
 import * as Events from './Events';
 import { BrowserEvents } from './Util/Browser';
 import { ExcaliburGraphicsContext } from './Graphics';
+import { Clock } from './Util/Clock';
 /**
  * Enum representing the different mousewheel event bubble prevention
  */
@@ -59,6 +59,12 @@ export interface EngineOptions {
     resolution?: ScreenDimension;
     /**
      * Optionally specify antialiasing (smoothing), by default true (smooth pixels)
+     *
+     *  * `true` - useful for high resolution art work you would like smoothed, this also hints excalibur to load images
+     * with [[ImageFiltering.Blended]]
+     *
+     *  * `false` - useful for pixel art style art work you would like sharp, this also hints excalibur to load images
+     * with [[ImageFiltering.Pixel]]
      */
     antialiasing?: boolean;
     /**
@@ -124,6 +130,13 @@ export interface EngineOptions {
      * Optionally set the background color
      */
     backgroundColor?: Color;
+    /**
+     * Optionally set the maximum fps if not set Excalibur will go as fast as the device allows.
+     *
+     * You may want to constrain max fps if your game cannot maintain fps consistently, it can look and feel better to have a 30fps game than
+     * one that bounces between 30fps and 60fps
+     */
+    maxFps?: number;
 }
 /**
  * The Excalibur Engine
@@ -134,7 +147,7 @@ export interface EngineOptions {
  */
 export declare class Engine extends Class implements CanInitialize, CanUpdate, CanDraw {
     /**
-     *
+     * Excalibur browser events abstraction used for wiring to native browser events safely
      */
     browser: BrowserEvents;
     /**
@@ -147,13 +160,28 @@ export declare class Engine extends Class implements CanInitialize, CanUpdate, C
     canvas: HTMLCanvasElement;
     /**
      * Direct access to the engine's 2D rendering context
+     * @deprecated Will be removed in v0.26.0, use Engine.graphicsContext
      */
     ctx: CanvasRenderingContext2D;
+    /**
+     * Direct access to the ExcaliburGraphicsContext used for drawing things to the screen
+     */
     graphicsContext: ExcaliburGraphicsContext;
     /**
      * Direct access to the canvas element ID, if an ID exists
      */
     canvasElementId: string;
+    /**
+     * Optionally set the maximum fps if not set Excalibur will go as fast as the device allows.
+     *
+     * You may want to constrain max fps if your game cannot maintain fps consistently, it can look and feel better to have a 30fps game than
+     * one that bounces between 30fps and 60fps
+     */
+    maxFps: number;
+    /**
+     * Direct access to the excalibur clock
+     */
+    clock: Clock;
     /**
      * The width of the game canvas in pixels (physical width component of the
      * resolution of the canvas element)
@@ -199,16 +227,17 @@ export declare class Engine extends Class implements CanInitialize, CanUpdate, C
     private _hasStarted;
     /**
      * Access Excalibur debugging functionality.
+     *
+     * Useful when you want to debug different aspects of built in engine features like
+     *   * Transform
+     *   * Graphics
+     *   * Colliders
      */
     debug: Debug;
     /**
      * Access [[stats]] that holds frame statistics.
      */
     get stats(): DebugStats;
-    /**
-     * Gets or sets the list of post processors to apply at the end of drawing a frame (such as [[ColorBlindCorrector]])
-     */
-    postProcessors: PostProcessor[];
     /**
      * The current [[Scene]] being drawn and updated on screen
      */
@@ -225,7 +254,7 @@ export declare class Engine extends Class implements CanInitialize, CanUpdate, C
     };
     /**
      * @hidden
-     * @deprecated
+     * @deprecated will be removed in v0.26.0
      */
     private _animations;
     /**
@@ -243,6 +272,7 @@ export declare class Engine extends Class implements CanInitialize, CanUpdate, C
     get pixelRatio(): number;
     /**
      * Indicates the current position of the engine. Valid only when DisplayMode is DisplayMode.Position
+     * @deprecated will be removed in v0.26.0
      */
     position: string | AbsolutePosition;
     /**
@@ -254,6 +284,10 @@ export declare class Engine extends Class implements CanInitialize, CanUpdate, C
      */
     private _isDebug;
     get isDebug(): boolean;
+    /**
+     * No longer used
+     * @deprecated will be removed in v0.26.0
+     */
     debugColor: Color;
     /**
      * Sets the background color for the engine.
@@ -263,6 +297,11 @@ export declare class Engine extends Class implements CanInitialize, CanUpdate, C
      * Sets the Transparency for the engine.
      */
     enableCanvasTransparency: boolean;
+    /**
+     * Hints the graphics context to truncate fractional world space coordinates
+     */
+    get snapToPixel(): boolean;
+    set snapToPixel(shouldSnapToPixel: boolean);
     /**
      * The action to take when a fatal exception is thrown
      */
@@ -276,7 +315,6 @@ export declare class Engine extends Class implements CanInitialize, CanUpdate, C
     private _compatible;
     private _timescale;
     private _loader;
-    private _isLoading;
     private _isInitialized;
     private _deferredGoTo;
     on(eventName: Events.initialize, handler: (event: Events.InitializeEvent<Engine>) => void): void;
@@ -555,13 +593,28 @@ export declare class Engine extends Class implements CanInitialize, CanUpdate, C
      * Returns true when loading is totally complete and the player has clicked start
      */
     get loadingComplete(): boolean;
+    private _isReady;
+    get ready(): boolean;
+    private _isReadyResolve;
+    private _isReadyPromise;
+    isReady(): Promise<void>;
     /**
      * 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.
+     *
+     * Note: start() only resolves AFTER the user has clicked the play button
      */
     start(loader?: Loader): Promise<void>;
+    private _mainloop;
+    /**
+     *
+     * @param game
+     * @param raf
+     * @param nowFn
+     * @deprecated Use [[Clock]] to run the mainloop, will be removed in v0.26.0
+     */
     static createMainLoop(game: Engine, raf: (func: Function) => number, nowFn: () => number): () => void;
     /**
      * Stops Excalibur's main loop, useful for pausing the game.
@@ -569,8 +622,13 @@ export declare class Engine extends Class implements CanInitialize, CanUpdate, C
     stop(): void;
     /**
      * Returns the Engine's Running status, Useful for checking whether engine is running or paused.
+     * @deprecated will be removed in v0.26.0, use isRunning()
      */
     isPaused(): boolean;
+    /**
+     * Returns the Engine's running status, Useful for checking whether engine is running or paused.
+     */
+    isRunning(): boolean;
     /**
      * Takes a screen shot of the current viewport and returns it as an
      * HTML Image Element.

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

@@ -9,9 +9,9 @@ export declare type ComponentType<ComponentToParse> = ComponentToParse extends C
  */
 export declare type ComponentStringType<T> = T extends Component<infer R> ? R : string;
 /**
- * Components are containers for state in Excalibur, the are meant to convey capabilities that an Entity posesses
+ * Components are containers for state in Excalibur, the are meant to convey capabilities that an Entity possesses
  *
- * Implementations of Component must have a zero-arg constructor to support dependecies
+ * Implementations of Component must have a zero-arg constructor to support dependencies
  *
  * ```typescript
  * class MyComponent extends ex.Component<'my'> {
@@ -47,7 +47,7 @@ export declare abstract class Component<TypeName extends string = string> {
      */
     onAdd?(owner: Entity): void;
     /**
-     * Opitonal callback called when acomponent is added to an entity
+     * Optional callback called when a component is added to an entity
      */
     onRemove?(previousOwner: Entity): void;
 }

package/build/dist/EntityComponentSystem/Components/MotionComponent.d.ts

@@ -22,7 +22,7 @@ export interface Motion {
      */
     torque: number;
     /**
-     * Inerita can be thought of as the resistance to motion
+     * Inertia can be thought of as the resistance to motion
      */
     inertia: number;
 }
@@ -49,7 +49,7 @@ export declare class MotionComponent extends Component<'ex.motion'> {
      */
     torque: number;
     /**
-     * Inerita can be thought of as the resistance to motion
+     * Inertia can be thought of as the resistance to motion
      */
     inertia: number;
 }

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

@@ -152,7 +152,7 @@ export declare class Entity extends Class implements OnInitialize, OnPreUpdate,
     /**
      * Adds a copy of all the components from another template entity as a "prefab"
      * @param templateEntity Entity to use as a template
-     * @param force Force component replacement if it aleady exists on the target entity
+     * @param force Force component replacement if it already exists on the target entity
      */
     addTemplate(templateEntity: Entity, force?: boolean): Entity;
     /**
@@ -197,20 +197,20 @@ export declare class Entity extends Class implements OnInitialize, OnPreUpdate,
     /**
      * Initializes this entity, meant to be called by the Scene before first update not by users of Excalibur.
      *
-     * It is not recommended that internal excalibur methods be overriden, do so at your own risk.
+     * It is not recommended that internal excalibur methods be overridden, do so at your own risk.
      *
      * @internal
      */
     _initialize(engine: Engine): void;
     /**
-     * It is not recommended that internal excalibur methods be overriden, do so at your own risk.
+     * It is not recommended that internal excalibur methods be overridden, do so at your own risk.
      *
      * Internal _preupdate handler for [[onPreUpdate]] lifecycle event
      * @internal
      */
     _preupdate(engine: Engine, delta: number): void;
     /**
-     * It is not recommended that internal excalibur methods be overriden, do so at your own risk.
+     * It is not recommended that internal excalibur methods be overridden, do so at your own risk.
      *
      * Internal _preupdate handler for [[onPostUpdate]] lifecycle event
      * @internal

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

@@ -42,7 +42,7 @@ export declare abstract class System<ComponentTypeUnion extends Component = Comp
     /**
      * System can execute in priority order, by default all systems are priority 0. Lower values indicated higher priority.
      * For a system to execute before all other a lower priority value (-1 for example) must be set.
-     * For a system to exectue after all other a higher priority value (10 for example) must be set.
+     * For a system to execute after all other a higher priority value (10 for example) must be set.
      */
     priority: number;
     /**

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

@@ -21,7 +21,6 @@ export declare class SystemManager<ContextType> {
     /**
      * Get a system registered in the manager by type
      * @param systemType
-     * @returns
      */
     get<T extends System>(systemType: SystemCtor<T>): T | null;
     /**
@@ -34,6 +33,12 @@ export declare class SystemManager<ContextType> {
      * @param system
      */
     removeSystem(system: System<any, ContextType>): void;
+    /**
+     * Initialize all systems in the manager
+     *
+     * Systems added after initialize() will be initialized on add
+     */
+    initialize(): void;
     /**
      * Updates all systems
      * @param type whether this is an update or draw system

package/build/dist/EventDispatcher.d.ts

@@ -3,11 +3,6 @@ import { Eventable } from './Interfaces/Evented';
 export declare class EventDispatcher<T = any> implements Eventable {
     private _handlers;
     private _wiredEventDispatchers;
-    private _target;
-    /**
-     * @param target  The object that will be the recipient of events from this event dispatcher
-     */
-    constructor(target: T);
     /**
      * Clears any existing handlers or wired event dispatchers on this event dispatcher
      */

package/build/dist/Events/ExEvent.d.ts

@@ -0,0 +1,6 @@
+export declare abstract class ExEvent<TName extends string> {
+    abstract readonly type: TName;
+    private _active;
+    get active(): boolean;
+    cancel(): void;
+}

package/build/dist/Events/PointerEvents.d.ts

@@ -0,0 +1,37 @@
+import { GlobalCoordinates } from '..';
+import { WheelDeltaMode } from '../Input/WheelDeltaMode';
+import { ExEvent } from './ExEvent';
+export declare abstract class PointerEvent extends ExEvent<'down' | 'up' | 'move' | 'cancel'> {
+    pointerId: number;
+    coordinates: GlobalCoordinates;
+    nativeEvent: Event;
+    constructor(pointerId: number, coordinates: GlobalCoordinates, nativeEvent: Event);
+}
+export declare class PointerUp extends PointerEvent {
+    readonly type = "up";
+}
+export declare class PointerDown extends PointerEvent {
+    readonly type = "down";
+}
+export declare class PointerMove extends PointerEvent {
+    readonly type = "move";
+}
+export declare class PointerCancel extends PointerEvent {
+    readonly type = "cancel";
+}
+export declare class Wheel extends ExEvent<'wheel'> {
+    x: number;
+    y: number;
+    pageX: number;
+    pageY: number;
+    screenX: number;
+    screenY: number;
+    index: number;
+    deltaX: number;
+    deltaY: number;
+    deltaZ: number;
+    deltaMode: WheelDeltaMode;
+    ev: Event;
+    readonly type = "wheel";
+    constructor(x: number, y: number, pageX: number, pageY: number, screenX: number, screenY: number, index: number, deltaX: number, deltaY: number, deltaZ: number, deltaMode: WheelDeltaMode, ev: Event);
+}

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

@@ -48,7 +48,7 @@ export interface Frame {
      */
     graphic?: Graphic;
     /**
-     * Optionally specify the number of ms the frame should be visible, overrids the animation duration (default 100 ms)
+     * Optionally specify the number of ms the frame should be visible, overrides the animation duration (default 100 ms)
      */
     duration?: number;
 }
@@ -103,6 +103,8 @@ export declare class Animation extends Graphic implements HasTick {
     private _playing;
     constructor(options: GraphicOptions & AnimationOptions);
     clone(): Animation;
+    get width(): number;
+    get height(): number;
     /**
      * Create an Animation from a [[SpriteSheet]], a list of indices into the sprite sheet, a duration per frame
      * and optional [[AnimationStrategy]]
@@ -184,6 +186,5 @@ export declare class Animation extends Graphic implements HasTick {
      * @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/Circle.d.ts

@@ -4,6 +4,8 @@ export interface CircleOptions {
 }
 /**
  * A circle [[Graphic]] for drawing circles to the [[ExcaliburGraphicsContext]]
+ *
+ * Circles default to [[ImageFiltering.Blended]]
  */
 export declare class Circle extends Raster {
     private _radius;