EngineObject

EngineObject

LittleJS Object Base Object Class
- Base object class used by the engine
- Automatically adds self to object list
- Will be updated and rendered each frame
- Renders as a sprite from a tilesheet by default
- Can have color and addtive color applied
- 2d Physics and collision system
- Sorted by renderOrder
- Objects can have children attached
- Parents are updated before children, and set child transform
- Call destroy() to get rid of objects

The physics system used by objects is simple and fast with some caveats...
- Collision uses the axis aligned size, the object's rotation angle is only for rendering
- Objects are guaranteed to not intersect tile collision from physics
- If an object starts or is moved inside tile collision, it will not collide with that tile
- Collision for objects can be set to be solid to block other objects
- Objects may get pushed into overlapping other solid objects, if so they will push away
- Solid objects are more performance intensive and should be used sparingly

Constructor

# new EngineObject(positionopt, sizeopt, tileIndexopt, tileSizeopt, angleopt, coloropt, renderOrderopt)

Create an engine object and adds it to the list of objects
Parameters:
Name Type Attributes Default Description
position Vector2 <optional>
new Vector2() World space position of the object
size Vector2 <optional>
objectDefaultSize World space size of the object
tileIndex Number <optional>
-1 Tile to use to render object (-1 is untextured)
tileSize Vector2 <optional>
tileSizeDefault Size of tile in source pixels
angle Number <optional>
0 Angle the object is rotated by
color Color <optional>
Color to apply to tile when rendered
renderOrder Number <optional>
0 Objects sorted by renderOrder before being rendered
Example
// create an engine object, normally you would first extend the class with your own
const pos = vec2(2,3);
const object = new EngineObject(pos); 

Members

# additiveColor

Properties
Type Description
Color Additive color to apply when rendered

# angle

Properties
Type Description
Number Angle to rotate the object

# angleDamping

Properties
Name Type Attributes Default Description
angleDamping Number <optional>
objectDefaultAngleDamping How much to slow down rotation each frame (0-1)

# angleVelocity

Properties
Name Type Attributes Default Description
angleVelocity Number <optional>
0 Angular velocity of the object

# color

Properties
Type Description
Color Color to apply when rendered

# damping

Properties
Name Type Attributes Default Description
damping Number <optional>
objectDefaultDamping How much to slow down velocity each frame (0-1)

# drawSize

Properties
Type Description
Vector2 Size of object used for drawing, uses size if not set

# elasticity

Properties
Name Type Attributes Default Description
elasticity Number <optional>
objectDefaultElasticity How bouncy the object is when colliding (0-1)

# friction

Properties
Name Type Attributes Default Description
friction Number <optional>
objectDefaultFriction How much friction to apply when sliding (0-1)

# gravityScale

Properties
Name Type Attributes Default Description
gravityScale Number <optional>
1 How much to scale gravity by for this object

# mass

Properties
Name Type Attributes Default Description
mass Number <optional>
objectDefaultMass How heavy the object is, static if 0

# pos

Properties
Type Description
Vector2 World space position of the object

# renderOrder

Properties
Name Type Attributes Default Description
renderOrder Number <optional>
0 Objects are sorted by render order

# size

Properties
Type Description
Vector2 World space width and height of the object

# tileIndex

Properties
Type Description
Number Tile to use to render object (-1 is untextured)

# tileSize

Properties
Type Description
Vector2 Size of tile in source pixels

# velocity

Properties
Name Type Attributes Default Description
velocity Vector2 <optional>
new Vector2() Velocity of the object

Methods

# addChild(child, localPosopt, localAngleopt)

Attaches a child to this with a given local transform
Parameters:
Name Type Attributes Default Description
child EngineObject
localPos Vector2 <optional>
new Vector2
localAngle Number <optional>
0

# applyAcceleration(acceleration)

Apply acceleration to this object (adjust velocity, not affected by mass)
Parameters:
Name Type Description
acceleration Vector2

# applyForce(force)

Apply force to this object (adjust velocity, affected by mass)
Parameters:
Name Type Description
force Vector2

# collideWithObject(object) → {Boolean}

Called to check if a tile raycast hit
Parameters:
Name Type Description
object EngineObject the object to test against
Returns:
- true if the collision should be resolved
Type
Boolean

# collideWithTile(tileData, pos) → {Boolean}

Called to check if a tile collision should be resolved
Parameters:
Name Type Description
tileData Number the value of the tile at the position
pos Vector2 tile where the collision occured
Returns:
- true if the collision should be resolved
Type
Boolean

# collideWithTileRaycast(tileData, pos) → {Boolean}

Called to check if a tile raycast hit
Parameters:
Name Type Description
tileData Number the value of the tile at the position
pos Vector2 tile where the raycast is
Returns:
- true if the raycast should hit
Type
Boolean

# destroy()

Destroy this object, destroy it's children, detach it's parent, and mark it for removal

# getAliveTime() → {Number}

How long since the object was created
Returns:
Type
Number

# getMirrorSign() → {Number}

Get the direction of the mirror
Returns:
-1 if this.mirror is true, or 1 if not mirrored
Type
Number

# removeChild(child)

Removes a child from this one
Parameters:
Name Type Description
child EngineObject

# render()

Render the object, draws a tile by default, automatically called each frame, sorted by renderOrder

# setCollision(collideSolidObjectsopt, isSolidopt, collideTilesopt)

Set how this object collides
Parameters:
Name Type Attributes Default Description
collideSolidObjects boolean <optional>
0 Does it collide with solid objects
isSolid boolean <optional>
0 Does it collide with and block other objects (expensive in large numbers)
collideTiles boolean <optional>
1 Does it collide with the tile collision

# update()

Update the object transform and physics, called automatically by engine once each frame