melonjs 17.4.0 → 18.0.0

package/src/renderable/draggable.js

@@ -1,114 +0,0 @@
-import Vector2d from "./../math/vector2.js";
-import * as input from "./../input/input.js";
-import * as event from "./../system/event.js";
-import Renderable from "./../renderable/renderable.js";
-
-/**
- * @classdesc
- * A Draggable base object
- * @see DropTarget
- * @augments Renderable
- */
-export class Draggable extends Renderable {
-    /**
-     * @param {number} x - the x coordinates of the draggable object
-     * @param {number} y - the y coordinates of the draggable object
-     * @param {number} width - draggable object width
-     * @param {number} height - draggable object height
-     */
-    constructor(x, y, width, height) {
-        super(x, y, width, height);
-        this.isKinematic = false;
-        this.dragging = false;
-        this.dragId = null;
-        this.grabOffset = new Vector2d(0, 0);
-        this.initEvents();
-    }
-
-    /**
-     * Initializes the events the modules needs to listen to
-     * It translates the pointer events to me.events
-     * in order to make them pass through the system and to make
-     * this module testable. Then we subscribe this module to the
-     * transformed events.
-     * @name initEvents
-     * @memberof Draggable
-     * @private
-     */
-    initEvents() {
-        input.registerPointerEvent("pointerdown", this, (e) => event.emit(event.DRAGSTART, e, this));
-        input.registerPointerEvent("pointerup", this,  (e) => event.emit(event.DRAGEND, e, this));
-        input.registerPointerEvent("pointercancel", this, (e) => event.emit(event.DRAGEND, e, this));
-        event.on(event.POINTERMOVE, (e) => this.dragMove(e));
-        event.on(event.DRAGSTART, (e, draggable) => {
-            if (draggable === this) {
-                this.dragStart(e);
-            }
-        });
-        event.on(event.DRAGEND, (e, draggable) => {
-            if (draggable === this) {
-                this.dragEnd(e);
-            }
-        });
-    }
-
-    /**
-     * Gets called when the user starts dragging the entity
-     * @name dragStart
-     * @memberof Draggable
-     * @param {object} e - the pointer event
-     * @returns {boolean} false if the object is being dragged
-     */
-    dragStart(e) {
-        if (this.dragging === false) {
-            this.dragging = true;
-            this.grabOffset.set(e.gameX, e.gameY);
-            this.grabOffset.sub(this.pos);
-            return false;
-        }
-    }
-
-    /**
-     * Gets called when the user drags this entity around
-     * @name dragMove
-     * @memberof Draggable
-     * @param {object} e - the pointer event
-     */
-    dragMove(e) {
-        if (this.dragging === true) {
-            this.pos.set(e.gameX, e.gameY, this.pos.z); //TODO : z ?
-            this.pos.sub(this.grabOffset);
-        }
-    }
-
-    /**
-     * Gets called when the user stops dragging the entity
-     * @name dragEnd
-     * @memberof Draggable
-     * @returns {boolean} false if the object stopped being dragged
-     */
-    dragEnd() {
-        if (this.dragging === true) {
-            this.dragging = false;
-            return false;
-        }
-    }
-
-    /**
-     * Destructor
-     * @name destroy
-     * @memberof Draggable
-     * @ignore
-     */
-    destroy() {
-        event.off(event.POINTERMOVE, this.dragMove);
-        event.off(event.DRAGSTART, this.dragStart);
-        event.off(event.DRAGEND, this.dragEnd);
-        input.releasePointerEvent("pointerdown", this);
-        input.releasePointerEvent("pointerup", this);
-        input.releasePointerEvent("pointercancel", this);
-        super.destroy();
-    }
-}
-
-

package/src/renderable/dragndrop.js

@@ -1,110 +0,0 @@
-import * as event from "./../system/event.js";
-import Renderable from "./../renderable/renderable.js";
-
-/**
- * additional import for TypeScript
- * @import { Draggable } from "./draggable.js";
- */
-
-/**
- * @classdesc
- * a base drop target object
- * @see Draggable
- * @augments Renderable
- */
-export class DropTarget extends Renderable {
-    /**
-     * @param {number} x - the x coordinates of the drop target
-     * @param {number} y - the y coordinates of the drop target
-     * @param {number} width - drop target width
-     * @param {number} height - drop target height
-     */
-    constructor(x, y, width, height) {
-        super(x, y, width, height);
-
-        this.isKinematic = false;
-
-        /**
-         * constant for the overlaps method
-         * @public
-         * @constant
-         * @type {string}
-         * @name CHECKMETHOD_OVERLAP
-         * @memberof DropTarget
-         */
-        this.CHECKMETHOD_OVERLAP = "overlaps";
-
-        /**
-         * constant for the contains method
-         * @public
-         * @constant
-         * @type {string}
-         * @name CHECKMETHOD_CONTAINS
-         * @memberof DropTarget
-         */
-        this.CHECKMETHOD_CONTAINS = "contains";
-
-        /**
-         * the checkmethod we want to use
-         * @public
-         * @constant
-         * @type {string}
-         * @name checkMethod
-         * @default "overlaps"
-         * @memberof DropTarget
-         */
-        this.checkMethod = this.CHECKMETHOD_OVERLAP;
-
-        event.on(event.DRAGEND, this.checkOnMe, this);
-
-    }
-
-    /**
-     * Sets the collision method which is going to be used to check a valid drop
-     * @name setCheckMethod
-     * @memberof DropTarget
-     * @param {string} checkMethod - the checkmethod (defaults to CHECKMETHOD_OVERLAP)
-     */
-    setCheckMethod(checkMethod) {
-        //  We can improve this check,
-        //  because now you can use every method in theory
-        if (typeof(this.getBounds()[this.checkMethod]) === "function") {
-            this.checkMethod = checkMethod;
-        }
-    }
-
-    /**
-     * Checks if a dropped entity is dropped on the current entity
-     * @name checkOnMe
-     * @memberof DropTarget
-     * @param {object} e - the triggering event
-     * @param {Draggable} draggable - the draggable object that is dropped
-     */
-    checkOnMe(e, draggable) {
-        if (draggable && this.getBounds()[this.checkMethod](draggable.getBounds())) {
-            // call the drop method on the current entity
-            this.drop(draggable);
-        }
-    }
-
-    /**
-     * Gets called when a draggable entity is dropped on the current entity
-     * @name drop
-     * @memberof DropTarget
-     * @param {Draggable} draggable - the draggable object that is dropped
-     */
-    drop(draggable) {  // eslint-disable-line no-unused-vars
-
-    }
-
-    /**
-     * Destructor
-     * @name destroy
-     * @memberof DropTarget
-     * @ignore
-     */
-    destroy() {
-        event.off(event.DRAGEND, this.checkOnMe);
-        super.destroy();
-    }
-}

package/src/renderable/entity/entity.js

@@ -1,254 +0,0 @@
-import pool from "../../system/pooling.js";
-import Renderable from "../renderable.js";
-import Sprite from "../sprite.js";
-import Body from "../../physics/body.js";
-
-/**
- * @import Line from "./../../geometries/line.js";
- * @import Rect from "./../../geometries/rectangle.js";
- * @import Ellipse from "./../../geometries/ellipse.js";
- * @import Polygon from "./../../geometries/poly.js";
- * @import Bounds from "./../../physics/bounds.js";
- * @import CanvasRenderer from "./../../video/canvas/canvas_renderer.js";
- * @import WebGLRenderer from "./../../video/webgl/webgl_renderer.js";
- **/
-
-/**
- * @classdesc
- * a Generic Object Entity
- * @augments Renderable
- */
-export default class Entity extends Renderable {
-    /**
-     * @param {number} x - the x coordinates of the entity object
-     * @param {number} y - the y coordinates of the entity object
-     * @param {object} settings - Entity properties, to be defined through Tiled or when calling the entity constructor
-     * <img src="images/object_properties.png"/>
-     * @param {number} settings.width - the physical width the entity takes up in game
-     * @param {number} settings.height - the physical height the entity takes up in game
-     * @param {string} [settings.name] - object entity name
-     * @param {string} [settings.id] - object unique IDs
-     * @param {Image|string} [settings.image] - resource name of a spritesheet to use for the entity renderable component
-     * @param {Vector2d} [settings.anchorPoint=0.0] - Entity anchor point
-     * @param {number} [settings.framewidth=settings.width] - width of a single frame in the given spritesheet
-     * @param {number} [settings.frameheight=settings.width] - height of a single frame in the given spritesheet
-     * @param {string} [settings.type] - object type
-     * @param {number} [settings.collisionMask] - Mask collision detection for this object
-     * @param {Rect[]|Polygon[]|Line[]|Ellipse[]} [settings.shapes] - the initial list of collision shapes (usually populated through Tiled)
-     */
-    constructor(x, y, settings) {
-
-        // ensure mandatory properties are defined
-        if ((typeof settings.width !== "number") || (typeof settings.height !== "number")) {
-            throw new Error("height and width properties are mandatory when passing settings parameters to an object entity");
-        }
-
-        // call the super constructor
-        super(x, y, settings.width, settings.height);
-
-        /**
-         * The array of renderable children of this entity.
-         * @ignore
-         */
-        this.children = [];
-
-        if (settings.image) {
-            // set the frame size to the given entity size, if not defined in settings
-            settings.framewidth = settings.framewidth || settings.width;
-            settings.frameheight = settings.frameheight || settings.height;
-            this.renderable = new Sprite(0, 0, settings);
-        }
-
-        // Update anchorPoint
-        if (settings.anchorPoint) {
-            this.anchorPoint.setMuted(settings.anchorPoint.x, settings.anchorPoint.y);
-        } else {
-            // for backward compatibility
-            this.anchorPoint.setMuted(0, 0);
-        }
-
-        // set the sprite name if specified
-        if (typeof (settings.name) === "string") {
-            this.name = settings.name;
-        }
-
-        /**
-         * object type (as defined in Tiled)
-         * @type {string}
-         */
-        this.type = settings.type || "";
-
-        /**
-         * object unique ID (as defined in Tiled)
-         * @type {number}
-         */
-        this.id = settings.id || "";
-
-        /**
-         * dead/living state of the entity<br>
-         * default value : true
-         * @type {boolean}
-         */
-        this.alive = true;
-
-        // initialize the default body
-        if (typeof settings.shapes === "undefined") {
-            settings.shapes = pool.pull("Polygon", 0, 0, [
-                pool.pull("Vector2d", 0,          0),
-                pool.pull("Vector2d", this.width, 0),
-                pool.pull("Vector2d", this.width, this.height),
-                pool.pull("Vector2d", 0,          this.height)
-            ]);
-        }
-
-        /**
-         * the entity body object
-         * @type {Body}
-         */
-        this.body = new Body(this, settings.shapes, () => this.onBodyUpdate());
-
-        // resize the entity if required
-        if (this.width === 0 && this.height === 0) {
-            this.resize(this.body.getBounds().width, this.body.getBounds().height);
-        }
-
-        // set the  collision mask and type (if defined)
-        this.body.setCollisionMask(settings.collisionMask);
-        this.body.setCollisionType(settings.collisionType);
-
-        // disable for entities
-        this.autoTransform = false;
-    }
-
-
-    /**
-     * The entity renderable component (can be any objects deriving from me.Renderable, like me.Sprite for example)
-     * @type {Renderable}
-     */
-
-    get renderable() {
-        return this.children[0];
-    }
-
-    set renderable(value) {
-        if (value instanceof Renderable) {
-            this.children[0] = value;
-            this.children[0].ancestor = this;
-            this.updateBounds();
-        } else {
-            throw new Error(value + "should extend me.Renderable");
-        }
-    }
-
-    /** @ignore */
-    update(dt) {
-        if (this.renderable) {
-            this.isDirty |= this.renderable.update(dt);
-        }
-        return super.update(dt);
-    }
-
-    /**
-     * update the bounding box for this entity.
-     * @param {boolean} [absolute=true] - update the bounds size and position in (world) absolute coordinates
-     * @returns {Bounds} this entity bounding box Rectangle object
-     */
-    updateBounds(absolute = true) {
-        let bounds = this.getBounds();
-
-        bounds.clear();
-        bounds.addFrame(
-            0,
-            0,
-            this.width,
-            this.height
-        );
-
-        // add each renderable bounds
-        if (this.children && this.children.length > 0) {
-            bounds.addBounds(this.children[0].getBounds());
-        }
-
-        if (this.body) {
-            bounds.addBounds(this.body.getBounds());
-        }
-
-        if (absolute === true) {
-            let absPos = this.getAbsolutePosition();
-            bounds.centerOn(absPos.x + bounds.x + bounds.width / 2,  absPos.y + bounds.y + bounds.height / 2);
-        }
-
-        return bounds;
-    }
-
-    /**
-     * update the bounds when the body is modified
-     */
-    onBodyUpdate() {
-        this.updateBounds();
-    }
-
-    preDraw(renderer) {
-        renderer.save();
-
-        // translate to the entity position
-        renderer.translate(
-            this.pos.x + this.body.getBounds().x,
-            this.pos.y + this.body.getBounds().y
-        );
-
-        if (this.renderable instanceof Renderable) {
-            // draw the child renderable's anchorPoint at the entity's
-            // anchor point.  the entity's anchor point is a scale from
-            // body position to body width/height
-            renderer.translate(
-                this.anchorPoint.x * this.body.getBounds().width,
-                this.anchorPoint.y * this.body.getBounds().height
-            );
-        }
-    }
-
-    /**
-     * draw this entity (automatically called by melonJS)
-     * @param {CanvasRenderer|WebGLRenderer} renderer - a renderer instance
-     * @param {Camera2d} [viewport] - the viewport to (re)draw
-     */
-    draw(renderer, viewport) {
-        let renderable = this.renderable;
-        if (renderable instanceof Renderable) {
-            // predraw (apply transforms)
-            renderable.preDraw(renderer);
-
-            // draw the object
-            renderable.draw(renderer, viewport);
-
-            // postdraw (clean-up);
-            renderable.postDraw(renderer);
-        }
-    }
-
-    /**
-     * Destroy function
-     * @ignore
-     */
-    destroy() {
-        // free some property objects
-        if (this.renderable) {
-            this.renderable.destroy.apply(this.renderable, arguments);
-            this.children.splice(0, 1);
-        }
-
-        // call the parent destroy method
-        super.destroy(arguments);
-    }
-
-    /**
-     * onDeactivateEvent Notification function
-     */
-    onDeactivateEvent() {
-        if (this.renderable && this.renderable.onDeactivateEvent) {
-            this.renderable.onDeactivateEvent();
-        }
-    }
-
-}