Class World

an object representing the physic world, and responsible for managing and updating all childs and physics

Hierarchy (view full)

Constructors

  • Parameters

    • Optionalx: number = 0

      position of the container (accessible via the inherited pos.x property)

    • Optionaly: number = 0

      position of the container (accessible via the inherited pos.y property)

    • Optionalwidth: number = Infinity

      width of the container

    • Optionalheight: number = Infinity

      height of the container

    Returns World

Properties

GUID: string

(G)ame (U)nique (Id)entifier"
a GUID will be allocated for any renderable object added
to an object container (including the me.game.world container)

alpha: number

Define the renderable opacity
Set to zero if you do not wish an object to be drawn

  • Renderable#setOpacity
  • Renderable#getOpacity
1.0
alwaysUpdate: boolean

Whether the renderable object will always update, even when outside of the viewport

false
ancestor: Container | Entity

a reference to the parent object that contains this renderable

undefined
anchorPoint: ObservablePoint

The anchor point is used for attachment behavior, and/or when applying transformations.
The coordinate system places the origin at the top left corner of the frame (0, 0) and (1, 1) means the bottom-right corner

a Renderable's anchor point defaults to (0.5,0.5), which corresponds to the center position.

Note: Object created through Tiled will have their anchorPoint set to (0, 0) to match Tiled Level editor implementation. To specify a value through Tiled, use a json expression like json:{"x":0.5,"y":0.5}.

<0.5,0.5>

the application (game) this physic world belong to

autoDepth: boolean

Specify if the children z index should automatically be managed by the parent container

true
autoSort: boolean

Specify if the children list should be automatically sorted when adding a new child

true
autoTransform: boolean

When enabled, an object container will automatically apply any defined transformation before calling the child draw method.

true
// enable "automatic" transformation when the object is activated
onActivateEvent: function () {
// reset the transformation matrix
this.currentTransform.identity();
// ensure the anchor point is the renderable center
this.anchorPoint.set(0.5, 0.5);
// enable auto transform
this.autoTransform = true;
....
}
backgroundColor: Color

define a background color for this container

(0, 0, 0, 0.0)
// add a red background color to this container
this.backgroundColor.setColor(255, 0, 0);
blendMode: string

the blend mode to be applied to this renderable (see renderer setBlendMode for available blend mode)

"normal"
  • CanvasRenderer#setBlendMode
  • WebGLRenderer#setBlendMode
bodies: Set<Body>

the active physic bodies in this simulation

body: Body

the renderable physic body

// define a new Player Class
class PlayerEntity extends me.Sprite {
// constructor
constructor(x, y, settings) {
// call the parent constructor
super(x, y , settings);

// define a basic walking animation
this.addAnimation("walk", [...]);
// define a standing animation (using the first frame)
this.addAnimation("stand", [...]);
// set the standing animation as default
this.setCurrentAnimation("stand");

// add a physic body
this.body = new me.Body(this);
// add a default collision shape
this.body.addShape(new me.Rect(0, 0, this.width, this.height));
// configure max speed, friction, and initial force to be applied
this.body.setMaxVelocity(3, 15);
this.body.setFriction(0.4, 0);
this.body.force.set(3, 0);
this.isKinematic = false;

// set the display to follow our position on both axis
me.game.viewport.follow(this.pos, me.game.viewport.AXIS.BOTH);
}

...

}
broadphase: QuadTree

the instance of the game world quadtree used for broadphase (used by the builtin physic and pointer event implementation)

clipping: boolean

Specify if the container draw operation should clip his children to its own bounds

false
currentTransform: Matrix2d

the renderable default transformation matrix

detector: Detector

the collision detector instance used by this world instance

edges: Vector2d[]

The edges here are the direction of the nth edge of the polygon, relative to the nth point. If you want to draw a given edge from the edge value, you must first translate to the position of the starting point.

enableChildBoundsUpdate: boolean

Specify if the container bounds should automatically take in account all child bounds when updated (this is expensive and disabled by default, only enable if necessary)

false
floating: boolean

If true, this renderable will be rendered using screen coordinates, as opposed to world coordinates. Use this, for example, to define UI elements.

false
fps: number

the rate at which the game world is updated, may be greater than or lower than the display fps

60

timer.maxfps

gravity: Vector2d

world gravity

<0,0.98>
indices: number[]

a list of indices for all vertices composing this polygon

isDirty: boolean

when true the renderable will be redrawn during the next update cycle

true
isKinematic: boolean

If true then physic collision and input events will not impact this renderable

true
isPersistent: boolean

make the renderable object persistent over level changes

false
mask:
    | Polygon
    | Rect
    | Ellipse
    | Line
    | RoundRect

A mask limits rendering elements to the shape and position of the given mask object. So, if the renderable is larger than the mask, only the intersecting part of the renderable will be visible.

undefined
// apply a mask in the shape of a Star
myNPCSprite.mask = new me.Polygon(myNPCSprite.width / 2, 0, [
// draw a star
{x: 0, y: 0},
{x: 14, y: 30},
{x: 47, y: 35},
{x: 23, y: 57},
{x: 44, y: 90},
{x: 0, y: 62},
{x: -44, y: 90},
{x: -23, y: 57},
{x: -47, y: 35},
{x: -14, y: 30}
]);
name: string

The name of the renderable

""
onChildChange: (() => void)

a callback to be extended, triggered after a child has been added or removed

onVisibilityChange: Function

an event handler that is called when the renderable leave or enter a camera viewport

undefined
this.onVisibilityChange = function(inViewport) {
if (inViewport === true) {
console.log("object has entered the in a camera viewport!");
}
};
physic: string

the physic engine used by melonJS

ApplicationSettings.physic

"builtin"
// disable builtin physic
me.game.world.physic = "none";
points: Vector2d[]

Array of points defining the Polygon
Note: If you manually change points, you must call recalcafterwards so that the changes get applied correctly.

origin point of the Polygon

preRender: boolean

Enabled pre-rendering for all tile layers.
If false layers are rendered dynamically, if true layers are first fully rendered into an offscreen canvas.
the "best" rendering method depends of your game (amount of layer, layer size, amount of tiles per layer, etc.)
Note : rendering method is also configurable per layer by adding a boolean "preRender" property to your layer in Tiled (https://doc.mapeditor.org/en/stable/manual/custom-properties/#adding-properties).

false
root: boolean

whether the container is the root of the scene

false
shader: GLShader

(Experimental) an optional shader, to be used instead of the default built-in one, when drawing this renderable (WebGL only)

undefined
sortOn: string

The property of the child object that should be used to sort on this container value : "x", "y", "z"

"z"
type: string = "Rectangle"

The shape type (used internally).

updateWhenPaused: boolean

Whether to update this object when the game is paused.

false

Accessors

  • get isFloating(): boolean
  • Whether the renderable object is floating (i.e. used screen coordinates), or contained in a floating parent container

    Returns boolean

    Renderable#floating

Methods

  • Add a child to the container
    if auto-sort is disable, the object will be appended at the bottom of the list. Adding a child to the container will automatically remove it from its other container. Meaning a child can only have one parent. This is important if you add a renderable to a container then add it to the World container it will move it out of the orginal container. Then when the World container reset() method is called the renderable will not be in any container.
    if the given child implements a onActivateEvent method, that method will be called once the child is added to this container.

    Parameters

    • child: any

      Child to be added

    • Optionalz: number

      forces the z index of the child to the specified value

    Returns Renderable

    the added child

  • Returns true if the polygon contains the given point.
    (Note: it is highly recommended to first do a hit test on the corresponding
    bounding rect, as the function can be highly consuming with complex shapes)

    Parameters

    • x: number

      x coordinate or a vector point to check

    • y: number

      y coordinate

    Returns boolean

    True if the polygon contain the point, otherwise false

    if (polygon.contains(10, 10)) {
    // do something
    }
    // or
    if (polygon.contains(myVector2d)) {
    // do something
    }
  • Returns true if the polygon contains the given point.
    (Note: it is highly recommended to first do a hit test on the corresponding
    bounding rect, as the function can be highly consuming with complex shapes)

    Parameters

    Returns boolean

    True if the polygon contain the point, otherwise false

    if (polygon.contains(10, 10)) {
    // do something
    }
    // or
    if (polygon.contains(myVector2d)) {
    // do something
    }
  • The forEach() method executes a provided function once per child element.
    the callback function is invoked with three arguments:

    • The current element being processed in the array
    • The index of element in the array.
    • The array forEach() was called upon.

    Parameters

    • callback: Function

      fnction to execute on each element

    • OptionalthisArg: object

      value to use as this(i.e reference Object) when executing callback.

    Returns void

    // iterate through all children of this container
    container.forEach((child) => {
    // do something with the child
    child.doSomething();
    });
    container.forEach((child, index) => { ... });
    container.forEach((child, index, array) => { ... });
    container.forEach((child, index, array) => { ... }, thisArg);
  • returns the list of childs with the specified name
    as defined in Tiled (Name field of the Object Properties)
    note : avoid calling this function every frame since it parses the whole object list each time

    Parameters

    • name:
          | string
          | number
          | boolean
          | RegExp

      child name

    Returns Renderable[]

    Array of children

  • return the child corresponding to the given property and value.
    note : avoid calling this function every frame since it parses the whole object tree each time

    Parameters

    • prop: string

      Property name

    • value:
          | string
          | number
          | boolean
          | RegExp

      Value of the property

    Returns Renderable[]

    Array of childs

    // get the first child object called "mainPlayer" in a specific container :
    let ent = myContainer.getChildByProp("name", "mainPlayer");

    // or query the whole world :
    let ent = container.getChildByProp("name", "mainPlayer");

    // partial property matches are also allowed by using a RegExp.
    // the following matches "redCOIN", "bluecoin", "bagOfCoins", etc :
    let allCoins = container.getChildByProp("name", /coin/i);

    // searching for numbers or other data types :
    let zIndex10 = container.getChildByProp("z", 10);
    let inViewport = container.getChildByProp("inViewport", true);
  • Returns true if the vertices composing this polygon form a convex shape (vertices must be in clockwise order).

    Returns null | boolean

    true if the vertices are convex, false if not, null if not computable

  • onCollision callback, triggered in case of collision, when this renderable body is colliding with another one

    Returns boolean

    true if the object should respond to the collision (its position and velocity will be corrected)

    // colision handler
    onCollision(response) {
    if (response.b.body.collisionType === me.collision.types.ENEMY_OBJECT) {
    // makes the other object solid, by substracting the overlap vector to the current position
    this.pos.sub(response.overlapV);
    this.hurt();
    // not solid
    return false;
    }
    // Make the object solid
    return true;
    },
  • Removes (and optionally destroys) a child from the container.
    (removal is immediate and unconditional)
    Never use keepalive=true with objects from pool. Doing so will create a memory leak.

    Parameters

    • child: any

      Child to be removed

    • Optionalkeepalive: boolean

      True to prevent calling child.destroy()

    Returns void

  • scale the renderable around his anchor point. Scaling actually applies changes to the currentTransform member wich is used by the renderer to scale the object when rendering. It does not scale the object itself. For example if the renderable is an image, the image.width and image.height properties are unaltered but the currentTransform member will be changed.

    Parameters

    • x: number

      a number representing the abscissa of the scaling vector.

    • Optionaly: number = x

      a number representing the ordinate of the scaling vector.

    Returns Renderable

    Reference to this object for method chaining

  • Automatically set the specified property of all childs to the given value

    Parameters

    • prop: string

      property name

    • value: object

      property value

    • Optionalrecursive: boolean

      recursively apply the value to child containers if true

    Returns void

  • update the builtin physic simulation by one step (called by the game world update method)

    Parameters

    • dt: number

      the time passed since the last frame update

    Returns void