excalibur 0.25.0 → 0.25.1

package/build/dist/Actor.js

@@ -1,856 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { Texture } from './Drawing/Texture';
-import { KillEvent, PreUpdateEvent, PreDrawEvent, PostKillEvent, PreKillEvent } from './Events';
-import { Sprite } from './Drawing/Sprite';
-import { Animation } from './Drawing/Animation';
-import { Logger } from './Util/Log';
-import { ActionContext } from './Actions/ActionContext';
-import { Vector, vec } from './Math/vector';
-import { BodyComponent } from './Collision/BodyComponent';
-import * as Traits from './Traits/Index';
-import { CollisionType } from './Collision/CollisionType';
-import { Entity } from './EntityComponentSystem/Entity';
-import { CanvasDrawComponent } from './Drawing/CanvasDrawComponent';
-import { TransformComponent } from './EntityComponentSystem/Components/TransformComponent';
-import { MotionComponent } from './EntityComponentSystem/Components/MotionComponent';
-import { GraphicsComponent } from './Graphics/GraphicsComponent';
-import { Rectangle } from './Graphics/Rectangle';
-import { Flags, Legacy } from './Flags';
-import { obsolete } from './Util/Decorators';
-import { ColliderComponent } from './Collision/ColliderComponent';
-import { Shape } from './Collision/Colliders/Shape';
-import { watch } from './Util/Watch';
-import { Circle } from './Graphics/Circle';
-/**
- * Type guard for checking if something is an Actor
- * @param x
- */
-export function isActor(x) {
-    return x instanceof Actor;
-}
-/**
- * The most important primitive in Excalibur is an `Actor`. Anything that
- * can move on the screen, collide with another `Actor`, respond to events,
- * 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 class Actor extends Entity {
-    // #endregion
-    /**
-     *
-     * @param config
-     */
-    constructor(config) {
-        super();
-        /**
-         * The anchor to apply all actor related transformations like rotation,
-         * translation, and scaling. By default the anchor is in the center of
-         * the actor. By default it is set to the center of the actor (.5, .5)
-         *
-         * An anchor of (.5, .5) will ensure that drawings are centered.
-         *
-         * Use `anchor.setTo` to set the anchor to a different point using
-         * values between 0 and 1. For example, anchoring to the top-left would be
-         * `Actor.anchor.setTo(0, 0)` and top-right would be `Actor.anchor.setTo(0, 1)`.
-         */
-        this._anchor = watch(Vector.Half, (v) => this._handleAnchorChange(v));
-        /**
-         * Convenience reference to the global logger
-         */
-        this.logger = Logger.getInstance();
-        /**
-         * The scene that the actor is in
-         */
-        this.scene = null;
-        this.frames = {};
-        /**
-         * Access to the current drawing for the actor, this can be
-         * an [[Animation]], [[Sprite]], or [[Polygon]].
-         * Set drawings with [[setDrawing]].
-         * @deprecated
-         */
-        this.currentDrawing = null;
-        /**
-         * Draggable helper
-         */
-        this._draggable = false;
-        this._dragging = false;
-        this._pointerDragStartHandler = () => {
-            this._dragging = true;
-        };
-        this._pointerDragEndHandler = () => {
-            this._dragging = false;
-        };
-        this._pointerDragMoveHandler = (pe) => {
-            if (this._dragging) {
-                this.pos = pe.pointer.lastWorldPos;
-            }
-        };
-        this._pointerDragLeaveHandler = (pe) => {
-            if (this._dragging) {
-                this.pos = pe.pointer.lastWorldPos;
-            }
-        };
-        /**
-         * Modify the current actor update pipeline.
-         */
-        this.traits = [];
-        /**
-         * Whether or not to enable the [[Traits.CapturePointer]] trait that propagates
-         * pointer events to this actor
-         */
-        this.enableCapturePointer = false;
-        /**
-         * Configuration for [[Traits.CapturePointer]] trait
-         */
-        this.capturePointer = {
-            captureMoveEvents: false,
-            captureDragEvents: false
-        };
-        // #region Events
-        this._capturePointerEvents = [
-            'pointerup',
-            'pointerdown',
-            'pointermove',
-            'pointerenter',
-            'pointerleave',
-            'pointerdragstart',
-            'pointerdragend',
-            'pointerdragmove',
-            'pointerdragenter',
-            'pointerdragleave'
-        ];
-        this._captureMoveEvents = [
-            'pointermove',
-            'pointerenter',
-            'pointerleave',
-            'pointerdragmove',
-            'pointerdragenter',
-            'pointerdragleave'
-        ];
-        this._captureDragEvents = [
-            'pointerdragstart',
-            'pointerdragend',
-            'pointerdragmove',
-            'pointerdragenter',
-            'pointerdragleave'
-        ];
-        const { name, x, y, pos, scale, width, height, radius, collider, vel, acc, rotation, angularVelocity, z, color, visible, anchor, collisionType, collisionGroup } = Object.assign({}, config);
-        this._setName(name);
-        this.anchor = anchor !== null && anchor !== void 0 ? anchor : Actor.defaults.anchor.clone();
-        this.addComponent(new TransformComponent());
-        this.pos = pos !== null && pos !== void 0 ? pos : vec(x !== null && x !== void 0 ? x : 0, y !== null && y !== void 0 ? y : 0);
-        this.rotation = rotation !== null && rotation !== void 0 ? rotation : 0;
-        this.scale = scale !== null && scale !== void 0 ? scale : vec(1, 1);
-        this.z = z !== null && z !== void 0 ? z : 0;
-        this.addComponent(new GraphicsComponent());
-        this.addComponent(new CanvasDrawComponent((ctx, delta) => this.draw(ctx, delta)));
-        this.addComponent(new MotionComponent());
-        this.vel = vel !== null && vel !== void 0 ? vel : Vector.Zero;
-        this.acc = acc !== null && acc !== void 0 ? acc : Vector.Zero;
-        this.angularVelocity = angularVelocity !== null && angularVelocity !== void 0 ? angularVelocity : 0;
-        this.addComponent(new BodyComponent());
-        this.body.collisionType = collisionType !== null && collisionType !== void 0 ? collisionType : CollisionType.Passive;
-        if (collisionGroup) {
-            this.body.group = collisionGroup;
-        }
-        if (collider) {
-            this.addComponent(new ColliderComponent(collider));
-        }
-        else if (radius) {
-            this.addComponent(new ColliderComponent(Shape.Circle(radius, this.anchor)));
-        }
-        else {
-            if (width > 0 && height > 0) {
-                this.addComponent(new ColliderComponent(Shape.Box(width, height, this.anchor)));
-            }
-            else {
-                this.addComponent(new ColliderComponent()); // no collider
-            }
-        }
-        this.graphics.visible = visible !== null && visible !== void 0 ? visible : true;
-        if (color) {
-            this.color = color;
-            if (width && height) {
-                this.graphics.add(new Rectangle({
-                    color: color,
-                    width,
-                    height
-                }));
-            }
-            else if (radius) {
-                this.graphics.add(new Circle({
-                    color: color,
-                    radius
-                }));
-            }
-        }
-        // Build default pipeline
-        if (Flags.isEnabled(Legacy.LegacyDrawing)) {
-            // TODO remove offscreen trait after legacy drawing removed
-            this.traits.push(new Traits.OffscreenCulling());
-        }
-        this.traits.push(new Traits.CapturePointer());
-        // Build the action queue
-        this.actions = new ActionContext(this);
-    }
-    /**
-     * The physics body the is associated with this actor. The body is the container for all physical properties, like position, velocity,
-     * acceleration, mass, inertia, etc.
-     */
-    get body() {
-        return this.get(BodyComponent);
-    }
-    /**
-     * Access the Actor's built in [[TransformComponent]]
-     */
-    get transform() {
-        return this.get(TransformComponent);
-    }
-    /**
-     * Access the Actor's built in [[MotionComponent]]
-     */
-    get motion() {
-        return this.get(MotionComponent);
-    }
-    /**
-     * Access to the Actor's built in [[GraphicsComponent]]
-     */
-    get graphics() {
-        return this.get(GraphicsComponent);
-    }
-    /**
-     * Access to the Actor's build in [[ColliderComponent]]
-     */
-    get collider() {
-        return this.get(ColliderComponent);
-    }
-    /**
-     * Gets the position vector of the actor in pixels
-     */
-    get pos() {
-        return this.transform.pos;
-    }
-    /**
-     * Sets the position vector of the actor in pixels
-     */
-    set pos(thePos) {
-        this.transform.pos = thePos.clone();
-    }
-    /**
-     * Gets the position vector of the actor from the last frame
-     */
-    get oldPos() {
-        return this.body.oldPos;
-    }
-    /**
-     * Sets the position vector of the actor in the last frame
-     */
-    set oldPos(thePos) {
-        this.body.oldPos.setTo(thePos.x, thePos.y);
-    }
-    /**
-     * Gets the velocity vector of the actor in pixels/sec
-     */
-    get vel() {
-        return this.motion.vel;
-    }
-    /**
-     * Sets the velocity vector of the actor in pixels/sec
-     */
-    set vel(theVel) {
-        this.motion.vel = theVel.clone();
-    }
-    /**
-     * Gets the velocity vector of the actor from the last frame
-     */
-    get oldVel() {
-        return this.body.oldVel;
-    }
-    /**
-     * Sets the velocity vector of the actor from the last frame
-     */
-    set oldVel(theVel) {
-        this.body.oldVel.setTo(theVel.x, theVel.y);
-    }
-    /**
-     * Gets the acceleration vector of the actor in pixels/second/second. An acceleration pointing down such as (0, 100) may be
-     * useful to simulate a gravitational effect.
-     */
-    get acc() {
-        return this.motion.acc;
-    }
-    /**
-     * Sets the acceleration vector of teh actor in pixels/second/second
-     */
-    set acc(theAcc) {
-        this.motion.acc = theAcc.clone();
-    }
-    /**
-     * Sets the acceleration of the actor from the last frame. This does not include the global acc [[Physics.acc]].
-     */
-    set oldAcc(theAcc) {
-        this.body.oldAcc.setTo(theAcc.x, theAcc.y);
-    }
-    /**
-     * Gets the acceleration of the actor from the last frame. This does not include the global acc [[Physics.acc]].
-     */
-    get oldAcc() {
-        return this.body.oldAcc;
-    }
-    /**
-     * Gets the rotation of the actor in radians. 1 radian = 180/PI Degrees.
-     */
-    get rotation() {
-        return this.transform.rotation;
-    }
-    /**
-     * Sets the rotation of the actor in radians. 1 radian = 180/PI Degrees.
-     */
-    set rotation(theAngle) {
-        this.transform.rotation = theAngle;
-    }
-    /**
-     * Gets the rotational velocity of the actor in radians/second
-     */
-    get angularVelocity() {
-        return this.motion.angularVelocity;
-    }
-    /**
-     * Sets the rotational velocity of the actor in radians/sec
-     */
-    set angularVelocity(angularVelocity) {
-        this.motion.angularVelocity = angularVelocity;
-    }
-    get scale() {
-        return this.get(TransformComponent).scale;
-    }
-    set scale(scale) {
-        this.get(TransformComponent).scale = scale;
-    }
-    get anchor() {
-        return this._anchor;
-    }
-    set anchor(vec) {
-        this._anchor = watch(vec, (v) => this._handleAnchorChange(v));
-        this._handleAnchorChange(vec);
-    }
-    _handleAnchorChange(v) {
-        if (this.graphics) {
-            this.graphics.anchor = v;
-        }
-    }
-    /**
-     * Indicates whether the actor is physically in the viewport
-     */
-    get isOffScreen() {
-        return this.hasTag('offscreen');
-    }
-    /**
-     * The visibility of an actor
-     * @deprecated Use [[GraphicsComponent.visible|Actor.graphics.visible]], will be removed in v0.26.0
-     */
-    get visible() {
-        return this.graphics.visible;
-    }
-    set visible(isVisible) {
-        this.graphics.visible = isVisible;
-    }
-    /**
-     * The opacity of an actor.
-     *
-     * @deprecated Actor.opacity will be removed in v0.26.0, use [[GraphicsComponent.opacity|Actor.graphics.opacity]].
-     */
-    get opacity() {
-        return this.graphics.opacity;
-    }
-    set opacity(opacity) {
-        this.graphics.opacity = opacity;
-    }
-    get draggable() {
-        return this._draggable;
-    }
-    set draggable(isDraggable) {
-        if (isDraggable) {
-            if (isDraggable && !this._draggable) {
-                this.on('pointerdragstart', this._pointerDragStartHandler);
-                this.on('pointerdragend', this._pointerDragEndHandler);
-                this.on('pointerdragmove', this._pointerDragMoveHandler);
-                this.on('pointerdragleave', this._pointerDragLeaveHandler);
-            }
-            else if (!isDraggable && this._draggable) {
-                this.off('pointerdragstart', this._pointerDragStartHandler);
-                this.off('pointerdragend', this._pointerDragEndHandler);
-                this.off('pointerdragmove', this._pointerDragMoveHandler);
-                this.off('pointerdragleave', this._pointerDragLeaveHandler);
-            }
-            this._draggable = isDraggable;
-        }
-    }
-    /**
-     * Sets the color of the actor. A rectangle of this color will be
-     * drawn if no [[Drawable]] is specified as the actors drawing.
-     *
-     * The default is `null` which prevents a rectangle from being drawn.
-     */
-    get color() {
-        return this._color;
-    }
-    set color(v) {
-        this._color = v.clone();
-    }
-    /**
-     * `onInitialize` is called before the first update of the actor. This method is meant to be
-     * overridden. This is where initialization of child actors should take place.
-     *
-     * Synonymous with the event handler `.on('initialize', (evt) => {...})`
-     */
-    onInitialize(_engine) {
-        // Override me
-    }
-    /**
-     * Initializes this actor and all it's child actors, meant to be called by the Scene before first update not by users of Excalibur.
-     *
-     * It is not recommended that internal excalibur methods be overridden, do so at your own risk.
-     *
-     * @internal
-     */
-    _initialize(engine) {
-        super._initialize(engine);
-        for (const child of this.children) {
-            child._initialize(engine);
-        }
-    }
-    _checkForPointerOptIn(eventName) {
-        if (eventName) {
-            const normalized = eventName.toLowerCase();
-            if (this._capturePointerEvents.indexOf(normalized) !== -1) {
-                this.enableCapturePointer = true;
-                if (this._captureMoveEvents.indexOf(normalized) !== -1) {
-                    this.capturePointer.captureMoveEvents = true;
-                }
-                if (this._captureDragEvents.indexOf(normalized) !== -1) {
-                    this.capturePointer.captureDragEvents = true;
-                }
-            }
-        }
-    }
-    on(eventName, handler) {
-        this._checkForPointerOptIn(eventName);
-        super.on(eventName, handler);
-    }
-    once(eventName, handler) {
-        this._checkForPointerOptIn(eventName);
-        super.once(eventName, handler);
-    }
-    off(eventName, handler) {
-        super.off(eventName, handler);
-    }
-    // #endregion
-    /**
-     * It is not recommended that internal excalibur methods be overridden, do so at your own risk.
-     *
-     * Internal _prekill handler for [[onPreKill]] lifecycle event
-     * @internal
-     */
-    _prekill(_scene) {
-        super.emit('prekill', new PreKillEvent(this));
-        this.onPreKill(_scene);
-    }
-    /**
-     * Safe to override onPreKill lifecycle event handler. Synonymous with `.on('prekill', (evt) =>{...})`
-     *
-     * `onPreKill` is called directly before an actor is killed and removed from its current [[Scene]].
-     */
-    onPreKill(_scene) {
-        // Override me
-    }
-    /**
-     * It is not recommended that internal excalibur methods be overridden, do so at your own risk.
-     *
-     * Internal _prekill handler for [[onPostKill]] lifecycle event
-     * @internal
-     */
-    _postkill(_scene) {
-        super.emit('postkill', new PostKillEvent(this));
-        this.onPostKill(_scene);
-    }
-    /**
-     * Safe to override onPostKill lifecycle event handler. Synonymous with `.on('postkill', (evt) => {...})`
-     *
-     * `onPostKill` is called directly after an actor is killed and remove from its current [[Scene]].
-     */
-    onPostKill(_scene) {
-        // Override me
-    }
-    /**
-     * If the current actor is a member of the scene, this will remove
-     * it from the scene graph. It will no longer be drawn or updated.
-     */
-    kill() {
-        if (this.scene) {
-            this._prekill(this.scene);
-            this.emit('kill', new KillEvent(this));
-            super.kill();
-            this._postkill(this.scene);
-        }
-        else {
-            this.logger.warn('Cannot kill actor, it was never added to the Scene');
-        }
-    }
-    /**
-     * If the current actor is killed, it will now not be killed.
-     */
-    unkill() {
-        this.active = true;
-    }
-    /**
-     * Indicates wether the actor has been killed.
-     */
-    isKilled() {
-        return !this.active;
-    }
-    setDrawing(key) {
-        key = key.toString();
-        if (this.currentDrawing !== this.frames[key]) {
-            if (this.frames[key] != null) {
-                this.frames[key].reset();
-                this.currentDrawing = this.frames[key];
-            }
-            else {
-                Logger.getInstance().error(`the specified drawing key ${key} does not exist`);
-            }
-        }
-        if (this.currentDrawing && this.currentDrawing instanceof Animation) {
-            this.currentDrawing.tick(0);
-        }
-    }
-    addDrawing() {
-        if (arguments.length === 2) {
-            this.frames[arguments[0]] = arguments[1];
-            if (!this.currentDrawing) {
-                this.currentDrawing = arguments[1];
-            }
-        }
-        else {
-            if (arguments[0] instanceof Sprite) {
-                this.addDrawing('default', arguments[0]);
-            }
-            if (arguments[0] instanceof Texture) {
-                this.addDrawing('default', arguments[0].asSprite());
-            }
-        }
-    }
-    /**
-     * Gets the z-index of an actor. The z-index determines the relative order an actor is drawn in.
-     * Actors with a higher z-index are drawn on top of actors with a lower z-index
-     */
-    get z() {
-        return this.get(TransformComponent).z;
-    }
-    /**
-     * @deprecated Use [[Actor.z]]
-     */
-    getZIndex() {
-        return this.get(TransformComponent).z;
-    }
-    /**
-     * Sets the z-index of an actor and updates it in the drawing list for the scene.
-     * The z-index determines the relative order an actor is drawn in.
-     * Actors with a higher z-index are drawn on top of actors with a lower z-index
-     * @param newZ new z-index to assign
-     */
-    set z(newZ) {
-        this.get(TransformComponent).z = newZ;
-    }
-    /**
-     * @param newIndex new z-index to assign
-     * @deprecated Use [[Actor.z]]
-     */
-    setZIndex(newIndex) {
-        this.get(TransformComponent).z = newIndex;
-    }
-    /**
-     * Get the center point of an actor
-     */
-    get center() {
-        return new Vector(this.pos.x + this.width / 2 - this.anchor.x * this.width, this.pos.y + this.height / 2 - this.anchor.y * this.height);
-    }
-    get width() {
-        return this.collider.localBounds.width * this.getGlobalScale().x;
-    }
-    get height() {
-        return this.collider.localBounds.height * this.getGlobalScale().y;
-    }
-    /**
-     * Gets this actor's rotation taking into account any parent relationships
-     *
-     * @returns Rotation angle in radians
-     */
-    getGlobalRotation() {
-        return this.get(TransformComponent).globalRotation;
-    }
-    /**
-     * Gets an actor's world position taking into account parent relationships, scaling, rotation, and translation
-     *
-     * @returns Position in world coordinates
-     */
-    getGlobalPos() {
-        return this.get(TransformComponent).globalPos;
-    }
-    /**
-     * Gets the global scale of the Actor
-     */
-    getGlobalScale() {
-        return this.get(TransformComponent).globalScale;
-    }
-    // #region Collision
-    /**
-     * Tests whether the x/y specified are contained in the actor
-     * @param x  X coordinate to test (in world coordinates)
-     * @param y  Y coordinate to test (in world coordinates)
-     * @param recurse checks whether the x/y are contained in any child actors (if they exist).
-     */
-    contains(x, y, recurse = false) {
-        const point = vec(x, y);
-        const collider = this.get(ColliderComponent);
-        collider.update();
-        const geom = collider.get();
-        if (!geom) {
-            return false;
-        }
-        const containment = geom.contains(point);
-        if (recurse) {
-            return (containment ||
-                this.children.some((child) => {
-                    return child.contains(x, y, true);
-                }));
-        }
-        return containment;
-    }
-    /**
-     * Returns true if the two actor.collider's surfaces are less than or equal to the distance specified from each other
-     * @param actor     Actor to test
-     * @param distance  Distance in pixels to test
-     */
-    within(actor, distance) {
-        const collider = this.get(ColliderComponent);
-        const otherCollider = actor.get(ColliderComponent);
-        const me = collider.get();
-        const other = otherCollider.get();
-        if (me && other) {
-            return me.getClosestLineBetween(other).getLength() <= distance;
-        }
-        return false;
-    }
-    // #endregion
-    // #region Update
-    /**
-     * Called by the Engine, updates the state of the actor
-     * @internal
-     * @param engine The reference to the current game engine
-     * @param delta  The time elapsed since the last update in milliseconds
-     */
-    update(engine, delta) {
-        this._initialize(engine);
-        this._preupdate(engine, delta);
-        // Tick animations
-        const drawing = this.currentDrawing;
-        if (drawing && drawing instanceof Animation) {
-            drawing.tick(delta, engine.stats.currFrame.id);
-        }
-        // Update action context
-        this.actions.update(delta);
-        // Update actor pipeline (movement, collision detection, event propagation, offscreen culling)
-        for (const trait of this.traits) {
-            trait.update(this, engine, delta);
-        }
-        // Update child actors
-        // for (let i = 0; i < this.children.length; i++) {
-        //   this.children[i].update(engine, delta);
-        // }
-        this._postupdate(engine, delta);
-    }
-    /**
-     * Safe to override onPreUpdate lifecycle event handler. Synonymous with `.on('preupdate', (evt) =>{...})`
-     *
-     * `onPreUpdate` is called directly before an actor is updated.
-     */
-    onPreUpdate(_engine, _delta) {
-        // Override me
-    }
-    /**
-     * Safe to override onPostUpdate lifecycle event handler. Synonymous with `.on('postupdate', (evt) =>{...})`
-     *
-     * `onPostUpdate` is called directly after an actor is updated.
-     */
-    onPostUpdate(_engine, _delta) {
-        // Override me
-    }
-    /**
-     * 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, delta) {
-        this.emit('preupdate', new PreUpdateEvent(engine, delta, this));
-        this.onPreUpdate(engine, delta);
-    }
-    /**
-     * It is not recommended that internal excalibur methods be overridden, do so at your own risk.
-     *
-     * Internal _preupdate handler for [[onPostUpdate]] lifecycle event
-     * @internal
-     */
-    _postupdate(engine, delta) {
-        this.emit('postupdate', new PreUpdateEvent(engine, delta, this));
-        this.onPostUpdate(engine, delta);
-    }
-    // endregion
-    // #region Drawing
-    /**
-     * Called by the Engine, draws the actor to the screen
-     * @param ctx   The rendering context
-     * @param delta The time since the last draw in milliseconds
-     *
-     * **Warning** only works with Flags.useLegacyDrawing() enabled
-     * @deprecated Use Actor.graphics, will be removed in v0.26.0
-     */
-    draw(ctx, delta) {
-        var _a;
-        // translate canvas by anchor offset
-        ctx.save();
-        if (this.currentDrawing) {
-            ctx.translate(-(this.width * this.anchor.x), -(this.height * this.anchor.y));
-            this._predraw(ctx, delta);
-            const drawing = this.currentDrawing;
-            // See https://github.com/excaliburjs/Excalibur/pull/619 for discussion on this formula
-            const offsetX = (this.width - drawing.width * drawing.scale.x) * this.anchor.x;
-            const offsetY = (this.height - drawing.height * drawing.scale.y) * this.anchor.y;
-            this.currentDrawing.draw({ ctx, x: offsetX, y: offsetY, opacity: this.graphics.opacity });
-        }
-        else {
-            this._predraw(ctx, delta);
-            if (this.color && this.collider) {
-                // update collider geometry based on transform
-                const collider = this.get(ColliderComponent);
-                collider.update();
-                if (collider && !collider.bounds.hasZeroDimensions()) {
-                    // Colliders are already shifted by anchor, unshift
-                    ctx.globalAlpha = this.graphics.opacity;
-                    (_a = collider.get()) === null || _a === void 0 ? void 0 : _a.draw(ctx, this.color, vec(0, 0));
-                }
-            }
-        }
-        ctx.restore();
-        this._postdraw(ctx, delta);
-    }
-    /**
-     * Safe to override onPreDraw lifecycle event handler. Synonymous with `.on('predraw', (evt) =>{...})`
-     *
-     * `onPreDraw` is called directly before an actor is drawn, but after local transforms are made.
-     *
-     * **Warning** only works with Flags.useLegacyDrawing() enabled
-     * @deprecated Use Actor.graphics.onPostDraw, will be removed in v0.26.0
-     */
-    onPreDraw(_ctx, _delta) {
-        // Override me
-    }
-    /**
-     * Safe to override onPostDraw lifecycle event handler. Synonymous with `.on('postdraw', (evt) =>{...})`
-     *
-     * `onPostDraw` is called directly after an actor is drawn, and before local transforms are removed.
-     *
-     * **Warning** only works with Flags.useLegacyDrawing() enabled
-     * @deprecated Use Actor.graphics.onPostDraw, will be removed in v0.26.0
-     */
-    onPostDraw(_ctx, _delta) {
-        // Override me
-    }
-    /**
-     * It is not recommended that internal excalibur methods be overridden, do so at your own risk.
-     *
-     * Internal _predraw handler for [[onPreDraw]] lifecycle event
-     *
-     * **Warning** only works with Flags.useLegacyDrawing() enabled
-     * @deprecated Use Actor.graphics.onPreDraw, will be removed in v0.26.0
-     * @internal
-     */
-    _predraw(ctx, delta) {
-        this.emit('predraw', new PreDrawEvent(ctx, delta, this));
-        this.onPreDraw(ctx, delta);
-    }
-    /**
-     * It is not recommended that internal excalibur methods be overridden, do so at your own risk.
-     *
-     * Internal _postdraw handler for [[onPostDraw]] lifecycle event
-     *
-     * **Warning** only works with Flags.useLegacyDrawing() enabled
-     * @deprecated Use Actor.graphics.onPostDraw, will be removed in v0.26.0
-     * @internal
-     */
-    _postdraw(ctx, delta) {
-        this.emit('postdraw', new PreDrawEvent(ctx, delta, this));
-        this.onPostDraw(ctx, delta);
-    }
-    /**
-     * Called by the Engine, draws the actors debugging to the screen
-     * @param ctx The rendering context
-     *
-     *
-     * **Warning** only works with Flags.useLegacyDrawing() enabled
-     * @deprecated Use Actor.graphics.onPostDraw, will be removed in v0.26.0
-     * @internal
-     */
-    /* istanbul ignore next */
-    debugDraw(_ctx) {
-        // pass
-    }
-}
-// #region Properties
-/**
- * Set defaults for all Actors
- */
-Actor.defaults = {
-    anchor: Vector.Half
-};
-__decorate([
-    obsolete({ message: 'Actor.visible will be removed in v0.26.0', alternateMethod: 'Use Actor.graphics.visible' })
-], Actor.prototype, "visible", null);
-__decorate([
-    obsolete({
-        message: 'Actor.opacity will be removed in v0.26.0',
-        alternateMethod: 'Use Actor.graphics.opacity'
-    })
-], Actor.prototype, "opacity", null);
-__decorate([
-    obsolete({
-        message: 'Actor.setDrawing will be removed in v0.26.0',
-        alternateMethod: 'Use Actor.graphics.show() or Actor.graphics.use()'
-    })
-], Actor.prototype, "setDrawing", null);
-__decorate([
-    obsolete({
-        message: 'Actor.addDrawing will be removed in v0.26.0',
-        alternateMethod: 'Use Actor.graphics.add()'
-    })
-], Actor.prototype, "addDrawing", null);
-__decorate([
-    obsolete({
-        message: 'Actor.getZIndex will be removed in v0.26.0',
-        alternateMethod: 'Use Actor.transform.z or Actor.z'
-    })
-], Actor.prototype, "getZIndex", null);
-__decorate([
-    obsolete({
-        message: 'Actor.setZIndex will be removed in v0.26.0',
-        alternateMethod: 'Use Actor.transform.z or Actor.z'
-    })
-], Actor.prototype, "setZIndex", null);
-//# sourceMappingURL=Actor.js.map