Class Body

constructor

• new Body(ancestor, shapes?, onBodyUpdate?): Body

• Parameters

  • ancestor:
    | Container
    | Renderable
    | Entity
    | Sprite
    | NineSliceSprite

    the parent object this body is attached to

  • Optionalshapes:
    | object
    | Point
    | Bounds
    | Point []
    | Polygon
    | Rect
    | Ellipse
    | Line
    | Rect []
    | Polygon []
    | Line []
    | Ellipse []
    | Bounds []

    a initial shape, list of shapes, or JSON object defining the body

  • OptionalonBodyUpdate: Function

    callback for when the body is updated (e.g. add/remove shapes)

  Returns Body

ancestor

undefined
Copy

bounce

0
Copy

bounds

collisionType

collision.types.ENEMY_OBJECT
Copy

// set the body collision type
body.collisionType = me.collision.types.PLAYER_OBJECT;
Copy

Readonlyfalling

false
Copy

force

<0,0>
Copy

// 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;
 } elseif (me.input.isKeyPressed("right")) {
this.body.force.x = this.body.maxVel.x;
 }
}
Copy

friction

<0,0>
Copy

gravityScale

1.0
Copy

ignoreGravity

false
Copy

ReadonlyisStatic

false
Copy

Readonlyjumping

false
Copy

mass

1
Copy

maxVel

<490,490>
Copy

onBodyUpdate

vel

<0,0>
Copy

addShape

• addShape(shape): number

• add a collision shape to this body
  (note: me.Rect objects will be converted to me.Polygon before being added)

  Parameters

  • shape:
    | object
    | Point
    | Bounds
    | Point []
    | Polygon
    | Rect
    | Ellipse
    | Line

    a shape or JSON object

  Returns number

  the shape array length

  Example

  // add a rectangle shape
  this.body.addShape(newme.Rect(0, 0, image.width, image.height));
  // add a shape from a JSON object
  this.body.addShape(me.loader.getJSON("shapesdef").banana);
  Copy

addVertices

• addVertices(vertices, index?): void

• add the given vertices to the body shape

  Parameters

  • vertices: Vector2d []

    an array of me.Vector2d points defining a convex hull

  • Optionalindex: number = 0

    the shape object for which to set the vertices

  Returns void

contains

• contains(...args): boolean

• Returns true if the any of the shape composing the body contains the given point.

  Parameters

  • Rest...args: any[]

  Returns boolean

  true if contains

  Example

  if (mySprite.body.contains(10, 10)) {
  // do something
  }
  // or
  if (mySprite.body.contains(myVector2d)) {
  // do something
  }
  Copy

forEach

• forEach(callback, thisArg?): void

• The forEach() method executes a provided function once per body shape 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

  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);
  Copy

fromJSON

• fromJSON(json, id?): number

• add collision mesh based on a JSON object (this will also apply any physic properties defined in the given JSON file)

  Parameters

  • json: object

    a JSON object as exported from a Physics Editor tool

  • Optionalid: string

    an optional shape identifier within the given the json object

  Returns number

  how many shapes were added to the body

  See

  https://www.codeandweb.com/physicseditor

  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");
  Copy

getBounds

• getBounds(): Bounds

• returns the AABB bounding box for this body

  Returns Bounds

  bounding box Rectangle object

getShape

• getShape(index?): Polygon | Ellipse | Line

• return the collision shape at the given index

  Parameters

  • Optionalindex: number

    the shape object at the specified index

  Returns Polygon | Ellipse | Line

  shape a shape object if defined

removeShape

• removeShape(shape): number

• remove the specified shape from the body shape list

  Parameters

  • shape: Polygon | Ellipse | Line

    a shape object

  Returns number

  the shape array length

removeShapeAt

• removeShapeAt(index): number

• remove the shape at the given index from the body shape list

  Parameters

  • index: number

    the shape object at the specified index

  Returns number

  the shape array length

respondToCollision

• respondToCollision(response): void

• the built-in function to solve the collision response

  Parameters

  • response: ResponseObject

    the collision response object

  Returns void

  See

  ResponseObject

rotate

• rotate(angle, v?): Body

• Rotate this body (counter-clockwise) by the specified angle (in radians). Unless specified the body will be rotated around its center point

  Parameters

  • angle: number

    The angle to rotate (in radians)

  • Optionalv: Vector2d = ...

    an optional point to rotate around

  Returns Body

  Reference to this object for method chaining

setCollisionMask

• setCollisionMask(bitmask?): void

• By default all physic bodies are able to collide with all other bodies,
  but it's also possible to specify 'collision filters' to provide a finer
  control over which body can collide with each other.

  Parameters

  • Optionalbitmask: number = collision.types.ALL_OBJECT

    the collision mask

  Returns void

  See

  collision.types

  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);
  Copy

setCollisionType

• setCollisionType(type): void

• define the collision type of the body for collision filtering

  Parameters

  • type: number

    the collision type

  Returns void

  See

  collision.types

  Example

  // set the body collision type
  body.collisionType = me.collision.types.PLAYER_OBJECT;
  Copy

setFriction

• setFriction(x?, y?): void

• set the body default friction

  Parameters

  • x: number = 0

    horizontal friction

  • y: number = 0

    vertical friction

  Returns void

setMaxVelocity

• setMaxVelocity(x, y): void

• cap the body velocity (body.maxVel property) to the specified value
  

  Parameters

  • x: number

    max velocity on x axis

  • y: number

    max velocity on y axis

  Returns void

setStatic

• setStatic(isStatic?): void

• set the body as a static body static body do not move automatically and do not check againt collision with others

  Parameters

  • OptionalisStatic: boolean = true

  Returns void

setVertices

• setVertices(vertices, index?, clear?): void

• set the body vertices to the given one

  Parameters

  • vertices: Vector2d []

    an array of me.Vector2d points defining a convex hull

  • Optionalindex: number = 0

    the shape object for which to set the vertices

  • Optionalclear: boolean = true

    either to reset the body definition before adding the new vertices

  Returns void

Protectedupdate

• update(): boolean
• Protected

  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.
  Updates to Body.vel are bounded by maxVel (which defaults to viewport size if not set)
  At this time a call to Body.Update does not call the onBodyUpdate callback that is listed in the constructor arguments.

  Returns boolean

  true if resulting velocity is different than 0