melonjs 14.2.0 → 14.4.0

package/dist/types/particles/emitter.d.ts

@@ -0,0 +1,188 @@
+/**
+ * @classdesc
+ * Particle Emitter Object.
+ * @augments Container
+ */
+export default class ParticleEmitter extends Container {
+    /**
+     * @param {number} x - x position of the particle emitter
+     * @param {number} y - y position of the particle emitter
+     * @param {ParticleEmitterSettings} [settings=ParticleEmitterSettings] - the settings for the particle emitter.
+     * @example
+     * // Create a particle emitter at position 100, 100
+     * var emitter = new ParticleEmitter(100, 100, {
+     *     width: 16,
+     *     height : 16,
+     *     tint: "#f00",
+     *     totalParticles: 32,
+     *     angle: 0,
+     *     angleVariation: 6.283185307179586,
+     *     maxLife: 5,
+     *     speed: 3
+     * });
+     *
+     * // Add the emitter to the game world
+     * me.game.world.addChild(emitter);
+     *
+     * // Launch all particles one time and stop, like a explosion
+     * emitter.burstParticles();
+     *
+     * // Launch constantly the particles, like a fountain
+     * emitter.streamParticles();
+     *
+     * // At the end, remove emitter from the game world
+     * // call this in onDestroyEvent function
+     * me.game.world.removeChild(emitter);
+     */
+    constructor(x: number, y: number, settings?: {
+        width: number;
+        height: number;
+        image: HTMLCanvasElement;
+        textureSize: number;
+        tint: string;
+        totalParticles: number;
+        angle: number;
+        angleVariation: number;
+        minLife: number;
+        maxLife: number;
+        speed: number;
+        speedVariation: number;
+        minRotation: number;
+        maxRotation: number;
+        minStartScale: number;
+        maxStartScale: number;
+        minEndScale: number;
+        maxEndScale: number;
+        gravity: number;
+        wind: number;
+        followTrajectory: boolean;
+        textureAdditive: boolean;
+        blendMode: string;
+        onlyInViewport: boolean;
+        floating: boolean;
+        maxParticles: number;
+        frequency: number;
+        duration: number;
+        framesToSkip: number;
+    } | undefined);
+    /**
+     * the current (active) emitter settings
+     * @public
+     * @type {ParticleEmitterSettings}
+     * @name settings
+     * @memberof ParticleEmitter
+     */
+    public settings: {
+        width: number;
+        height: number;
+        image: HTMLCanvasElement;
+        textureSize: number;
+        tint: string;
+        totalParticles: number;
+        angle: number;
+        angleVariation: number;
+        minLife: number;
+        maxLife: number;
+        speed: number;
+        speedVariation: number;
+        minRotation: number;
+        maxRotation: number;
+        minStartScale: number;
+        maxStartScale: number;
+        minEndScale: number;
+        maxEndScale: number;
+        gravity: number;
+        wind: number;
+        followTrajectory: boolean;
+        textureAdditive: boolean;
+        blendMode: string;
+        onlyInViewport: boolean;
+        floating: boolean;
+        maxParticles: number;
+        frequency: number;
+        duration: number;
+        framesToSkip: number;
+    };
+    /** @ignore */
+    _stream: boolean;
+    /** @ignore */
+    _frequencyTimer: number;
+    /** @ignore */
+    _durationTimer: number;
+    /** @ignore */
+    _enabled: boolean;
+    _updateCount: number;
+    _dt: number;
+    /**
+     * Reset the emitter with particle emitter settings.
+     * @param {ParticleEmitterSettings} settings - [optional] object with emitter settings. See {@link ParticleEmitterSettings}
+     */
+    reset(settings?: {
+        width: number;
+        height: number;
+        image: HTMLCanvasElement;
+        textureSize: number;
+        tint: string;
+        totalParticles: number;
+        angle: number;
+        angleVariation: number;
+        minLife: number;
+        maxLife: number;
+        speed: number;
+        speedVariation: number;
+        minRotation: number;
+        maxRotation: number;
+        minStartScale: number;
+        maxStartScale: number;
+        minEndScale: number;
+        maxEndScale: number;
+        gravity: number;
+        wind: number;
+        followTrajectory: boolean;
+        textureAdditive: boolean;
+        blendMode: string;
+        onlyInViewport: boolean;
+        floating: boolean;
+        maxParticles: number;
+        frequency: number;
+        duration: number;
+        framesToSkip: number;
+    }): void;
+    _defaultParticle: object | undefined;
+    /**
+     * returns a random point on the x axis within the bounds of this emitter
+     * @returns {number}
+     */
+    getRandomPointX(): number;
+    /**
+     * returns a random point on the y axis within the bounds this emitter
+     * @returns {number}
+     */
+    getRandomPointY(): number;
+    /** @ignore */
+    addParticles(count: any): void;
+    /**
+     * Emitter is of type stream and is launching particles
+     * @returns {boolean} Emitter is Stream and is launching particles
+     */
+    isRunning(): boolean;
+    /**
+     * Launch particles from emitter constantly (e.g. for stream)
+     * @param {number} duration - [optional] time that the emitter releases particles in ms
+     */
+    streamParticles(duration: number): void;
+    /**
+     * Stop the emitter from generating new particles (used only if emitter is Stream)
+     */
+    stopStream(): void;
+    /**
+     * Launch all particles from emitter and stop (e.g. for explosion)
+     * @param {number} total - [optional] number of particles to launch
+     */
+    burstParticles(total: number): void;
+    /**
+     * @ignore
+     */
+    update(dt: any): boolean;
+}
+import Container from "./../renderable/container.js";

package/dist/types/particles/particle.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @classdesc
+ * Single Particle Object.
+ * @augments Renderable
+ */
+export default class Particle extends Renderable {
+    /**
+     * @param {ParticleEmitter} emitter - the particle emitter
+     */
+    constructor(emitter: ParticleEmitter);
+    /**
+     * @ignore
+     */
+    onResetEvent(emitter: any, newInstance?: boolean): void;
+    vel: object | undefined;
+    image: any;
+    life: any;
+    startLife: any;
+    startScale: number | undefined;
+    endScale: number | undefined;
+    gravity: any;
+    wind: any;
+    followTrajectory: any;
+    onlyInViewport: any;
+    _deltaInv: number | undefined;
+    angle: number | undefined;
+    /**
+     * @ignore
+     */
+    draw(renderer: any): void;
+}
+import Renderable from "./../renderable/renderable.js";

package/dist/types/particles/settings.d.ts

@@ -0,0 +1,32 @@
+export default ParticleEmitterSettings;
+declare namespace ParticleEmitterSettings {
+    const width: number;
+    const height: number;
+    const image: HTMLCanvasElement;
+    const textureSize: number;
+    const tint: string;
+    const totalParticles: number;
+    const angle: number;
+    const angleVariation: number;
+    const minLife: number;
+    const maxLife: number;
+    const speed: number;
+    const speedVariation: number;
+    const minRotation: number;
+    const maxRotation: number;
+    const minStartScale: number;
+    const maxStartScale: number;
+    const minEndScale: number;
+    const maxEndScale: number;
+    const gravity: number;
+    const wind: number;
+    const followTrajectory: boolean;
+    const textureAdditive: boolean;
+    const blendMode: string;
+    const onlyInViewport: boolean;
+    const floating: boolean;
+    const maxParticles: number;
+    const frequency: number;
+    const duration: number;
+    const framesToSkip: number;
+}

package/dist/types/physics/body.d.ts

@@ -0,0 +1,330 @@
+/**
+ * @classdesc
+ * a Generic Physic Body Object with some physic properties and behavior functionality, to as a member of a Renderable.
+ * @see Renderable.body
+ */
+export default class Body {
+    /**
+     * @param {Renderable} ancestor - the parent object this body is attached to
+     * @param {Rect|Rect[]|Polygon|Polygon[]|Line|Line[]|Ellipse|Ellipse[]|Point|Point[]|Bounds|Bounds[]|object} [shapes] - a initial shape, list of shapes, or JSON object defining the body
+     * @param {Function} [onBodyUpdate] - callback for when the body is updated (e.g. add/remove shapes)
+     */
+    constructor(ancestor: Renderable, shapes?: Rect | Rect[] | Polygon | Polygon[] | Line | Line[] | Ellipse | Ellipse[] | Point | Point[] | Bounds | Bounds[] | object, onBodyUpdate?: Function | undefined);
+    /**
+     * a reference to the parent object that contains this body,
+     * or undefined if it has not been added to one.
+     * @public
+     * @type {Renderable}
+     * @default undefined
+     */
+    public ancestor: Renderable;
+    /**
+     * The AABB bounds box reprensenting this body
+     * @public
+     * @type {Bounds}
+     */
+    public bounds: Bounds;
+    /**
+     * The collision shapes of the body
+     * @ignore
+     * @type {Polygon[]|Line[]|Ellipse[]|Point|Point[]}
+     */
+    shapes: Polygon[] | Line[] | Ellipse[] | Point | Point[];
+    /**
+     * The body collision mask, that defines what should collide with what.<br>
+     * (by default will collide with all entities)
+     * @ignore
+     * @type {number}
+     * @default collision.types.ALL_OBJECT
+     * @see collision.types
+     */
+    collisionMask: number;
+    /**
+     * define the collision type of the body for collision filtering
+     * @public
+     * @type {number}
+     * @default collision.types.ENEMY_OBJECT
+     * @see collision.types
+     * @example
+     * // set the body collision type
+     * body.collisionType = me.collision.types.PLAYER_OBJECT;
+     */
+    public collisionType: number;
+    /**
+     * The current velocity of the body.
+     * See to apply a force if you need to modify a body velocity
+     * @see Body.force
+     * @public
+     * @type {Vector2d}
+     * @default <0,0>
+     */
+    public vel: Vector2d;
+    /**
+     * body force to apply to this the body in the current step.
+     * (any positive or negative force will be cancelled after every world/body update cycle)
+     * @public
+     * @type {Vector2d}
+     * @default <0,0>
+     * @see Body.setMaxVelocity
+     * @example
+     * // define a default maximum acceleration, initial force and friction
+     * this.body.force.set(1, 0);
+     * this.body.friction.set(0.4, 0);
+     * this.body.setMaxVelocity(3, 15);
+     *
+     * // apply a postive or negative force when pressing left of right key
+     * update(dt) {
+     *     if (me.input.isKeyPressed("left"))    {
+     *          this.body.force.x = -this.body.maxVel.x;
+     *      } else if (me.input.isKeyPressed("right")) {
+     *         this.body.force.x = this.body.maxVel.x;
+     *     }
+     * }
+     */
+    public force: Vector2d;
+    /**
+     * body friction
+     * @public
+     * @type {Vector2d}
+     * @default <0,0>
+     */
+    public friction: Vector2d;
+    /**
+     * the body bouciness level when colliding with other solid bodies :
+     * a value of 0 will not bounce, a value of 1 will fully rebound.
+     * @public
+     * @type {number}
+     * @default 0
+     */
+    public bounce: number;
+    /**
+     * the body mass
+     * @public
+     * @type {number}
+     * @default 1
+     */
+    public mass: number;
+    /**
+     * max velocity (to limit body velocity)
+     * @public
+     * @type {Vector2d}
+     * @default <490,490>
+     */
+    public maxVel: Vector2d;
+    /**
+     * Either this body is a static body or not.
+     * A static body is completely fixed and can never change position or angle.
+     * @readonly
+     * @public
+     * @type {boolean}
+     * @default false
+     */
+    public readonly isStatic: boolean;
+    /**
+     * The degree to which this body is affected by the world gravity
+     * @public
+     * @see World.gravity
+     * @type {number}
+     * @default 1.0
+     */
+    public gravityScale: number;
+    /**
+     * If true this body won't be affected by the world gravity
+     * @public
+     * @see World.gravity
+     * @type {boolean}
+     * @default false
+     */
+    public ignoreGravity: boolean;
+    /**
+     * falling state of the body<br>
+     * true if the object is falling<br>
+     * false if the object is standing on something<br>
+     * @readonly
+     * @public
+     * @type {boolean}
+     * @default false
+     */
+    public readonly falling: boolean;
+    /**
+     * jumping state of the body<br>
+     * equal true if the body is jumping<br>
+     * @readonly
+     * @public
+     * @type {boolean}
+     * @default false
+     */
+    public readonly jumping: boolean;
+    onBodyUpdate: Function | undefined;
+    /**
+     * set the body as a static body
+     * static body do not move automatically and do not check againt collision with others
+     * @param {boolean} [isStatic=true]
+     */
+    setStatic(isStatic?: boolean | undefined): void;
+    /**
+     * add a collision shape to this body <br>
+     * (note: me.Rect objects will be converted to me.Polygon before being added)
+     * @param {Rect|Polygon|Line|Ellipse|Point|Point[]|Bounds|object} shape - a shape or JSON object
+     * @returns {number} the shape array length
+     * @example
+     * // add a rectangle shape
+     * this.body.addShape(new me.Rect(0, 0, image.width, image.height));
+     * // add a shape from a JSON object
+     * this.body.addShape(me.loader.getJSON("shapesdef").banana);
+     */
+    addShape(shape: Rect | Polygon | Line | Ellipse | Point | Point[] | Bounds | object): number;
+    /**
+     * set the body vertices to the given one
+     * @param {Vector2d[]} vertices - an array of me.Vector2d points defining a convex hull
+     * @param {number} [index=0] - the shape object for which to set the vertices
+     * @param {boolean} [clear=true] - either to reset the body definition before adding the new vertices
+     */
+    setVertices(vertices: Vector2d[], index?: number | undefined, clear?: boolean | undefined): void;
+    /**
+     * add the given vertices to the body shape
+     * @param {Vector2d[]} vertices - an array of me.Vector2d points defining a convex hull
+     * @param {number} [index=0] - the shape object for which to set the vertices
+     */
+    addVertices(vertices: Vector2d[], index?: number | undefined): void;
+    /**
+     * add collision mesh based on a JSON object
+     * (this will also apply any physic properties defined in the given JSON file)
+     * @param {object} json - a JSON object as exported from a Physics Editor tool
+     * @param {string} [id] - an optional shape identifier within the given the json object
+     * @see https://www.codeandweb.com/physicseditor
+     * @returns {number} how many shapes were added to the body
+     * @example
+     * // define the body based on the banana shape
+     * this.body.fromJSON(me.loader.getJSON("shapesdef").banana);
+     * // or ...
+     * this.body.fromJSON(me.loader.getJSON("shapesdef"), "banana");
+     */
+    fromJSON(json: object, id?: string | undefined): number;
+    /**
+     * return the collision shape at the given index
+     * @param {number} [index=0] - the shape object at the specified index
+     * @returns {Polygon|Line|Ellipse} shape a shape object if defined
+     */
+    getShape(index?: number | undefined): Polygon | Line | Ellipse;
+    /**
+     * returns the AABB bounding box for this body
+     * @returns {Bounds} bounding box Rectangle object
+     */
+    getBounds(): Bounds;
+    /**
+     * remove the specified shape from the body shape list
+     * @param {Polygon|Line|Ellipse} shape - a shape object
+     * @returns {number} the shape array length
+     */
+    removeShape(shape: Polygon | Line | Ellipse): number;
+    /**
+     * remove the shape at the given index from the body shape list
+     * @param {number} index - the shape object at the specified index
+     * @returns {number} the shape array length
+     */
+    removeShapeAt(index: number): number;
+    /**
+     * By default all physic bodies are able to collide with all other bodies, <br>
+     * but it's also possible to specify 'collision filters' to provide a finer <br>
+     * control over which body can collide with each other.
+     * @see collision.types
+     * @param {number} [bitmask = collision.types.ALL_OBJECT] - the collision mask
+     * @example
+     * // filter collision detection with collision shapes, enemies and collectables
+     * body.setCollisionMask(me.collision.types.WORLD_SHAPE | me.collision.types.ENEMY_OBJECT | me.collision.types.COLLECTABLE_OBJECT);
+     * ...
+     * // disable collision detection with all other objects
+     * body.setCollisionMask(me.collision.types.NO_OBJECT);
+     */
+    setCollisionMask(bitmask?: number | undefined): void;
+    /**
+     * define the collision type of the body for collision filtering
+     * @see collision.types
+     * @param {number} type - the collision type
+     * @example
+     * // set the body collision type
+     * body.collisionType = me.collision.types.PLAYER_OBJECT;
+     */
+    setCollisionType(type: number): void;
+    /**
+     * the built-in function to solve the collision response
+     * @param {object} response - the collision response object (see {@link ResponseObject})
+     */
+    respondToCollision(response: object): void;
+    /**
+     * The forEach() method executes a provided function once per body shape element. <br>
+     * the callback function is invoked with three arguments: <br>
+     *    - The current element being processed in the array <br>
+     *    - The index of element in the array. <br>
+     *    - The array forEach() was called upon. <br>
+     * @param {Function} callback - fnction to execute on each element
+     * @param {object} [thisArg] - value to use as this(i.e reference Object) when executing callback.
+     * @example
+     * // iterate through all shapes of the physic body
+     * mySprite.body.forEach((shape) => {
+     *    shape.doSomething();
+     * });
+     * mySprite.body.forEach((shape, index) => { ... });
+     * mySprite.body.forEach((shape, index, array) => { ... });
+     * mySprite.body.forEach((shape, index, array) => { ... }, thisArg);
+     */
+    forEach(callback: Function, thisArg?: object | undefined, ...args: any[]): void;
+    /**
+     * Returns true if the any of the shape composing the body contains the given point.
+     * @method Body#contains
+     * @param {Vector2d} point
+     * @returns {boolean} true if contains
+     */
+    /**
+     * Returns true if the any of the shape composing the body contains the given point.
+     * @param  {number} x -  x coordinate
+     * @param  {number} y -  y coordinate
+     * @returns {boolean} true if contains
+     */
+    contains(...args: any[]): boolean;
+    /**
+     * Rotate this body (counter-clockwise) by the specified angle (in radians).
+     * Unless specified the body will be rotated around its center point
+     * @param {number} angle - The angle to rotate (in radians)
+     * @param {Vector2d|ObservableVector2d} [v=Body.getBounds().center] - an optional point to rotate around
+     * @returns {Body} Reference to this object for method chaining
+     */
+    rotate(angle: number, v?: Vector2d | ObservableVector2d): Body;
+    /**
+     * cap the body velocity (body.maxVel property) to the specified value<br>
+     * @param {number} x - max velocity on x axis
+     * @param {number} y - max velocity on y axis
+     */
+    setMaxVelocity(x: number, y: number): void;
+    /**
+     * set the body default friction
+     * @param {number} x - horizontal friction
+     * @param {number} y - vertical friction
+     */
+    setFriction(x?: number, y?: number): void;
+    /**
+     * Updates the parent's position as well as computes the new body's velocity based
+     * on the values of force/friction.  Velocity chages are proportional to the
+     * me.timer.tick value (which can be used to scale velocities).  The approach to moving the
+     * parent renderable is to compute new values of the Body.vel property then add them to
+     * the parent.pos value thus changing the postion the amount of Body.vel each time the
+     * update call is made. <br>
+     * Updates to Body.vel are bounded by maxVel (which defaults to viewport size if not set) <br>
+     * At this time a call to Body.Update does not call the onBodyUpdate callback that is listed in the constructor arguments.
+     * @protected
+     * @param {number} dt - time since the last update in milliseconds.
+     * @returns {boolean} true if resulting velocity is different than 0
+     */
+    protected update(dt: number): boolean;
+    /**
+     * Destroy function<br>
+     * @ignore
+     */
+    destroy(): void;
+}
+import Bounds from "./bounds.js";
+import Polygon from "./../geometries/poly.js";
+import Ellipse from "./../geometries/ellipse.js";
+import Point from "../geometries/point.js";
+import Rect from "./../geometries/rectangle.js";