Setup and Update

The code inside the q5.js (or p5.js) setup function runs when the program starts. The update function runs 60 times per second by default.

The new Canvas() constructor creates a section of the screen that the program can draw on.

Try changing the width and height of the canvas (the numbers inside the Canvas constructor), then restart the example program!

What is a sprite?

A sprite is a ghost!

Video game developers use the word "sprite" to refer to characters, items, or anything else that moves above a background.

The new Sprite() constructor creates a sprite object, which contains variables that define a sprite’s position, size, and appearance.

Try editing the properties of the box and circle sprites in the code examples below!

Sprite physics

A sprite's collider is used to detect collisions with other sprites. By default, sprites have a DYNAMIC physics collider that allows the sprite to move freely and be affected by gravity.

STATIC colliders can't be moved. KINEMATIC colliders can be moved programmatically but not by other sprites. They also won't collide with other kinematic colliders. Setting a sprite's collider type to NONE makes it have no collider.

The collider type can also be set using abbreviations of collider type name: DYN, STA, or KIN.

Click the reload icon on the top right corner of a code example to replay it!

Sprites with an Image

sprite.image (aka sprite.img) can be set to a Q5.Image or a url path to an image file.

If you need an image to be loaded before your program starts, it's best to use loadImage inside the q5 preload function.

sprite.image.offset can be used to offset the image relative to the sprite's center. This can help better align the image with the sprite's physics collider.

Try clicking on the canvas of this example. When the sprite.debug property is set to true you can see the sprite's physics body collider.

Set a sprite's opacity to change the transparency of its appearance. Use a value between 0 (completely transparent) and 1 (completely opaque).

sprite.image.scale changes the display size of the sprite's image. The default is 1.0. If the image appears way too big or small, you should probably change the size of the image file itself.

Emoji Sprites

No images? 🫥 No problem! 😄

You can use any emoji as the image for your sprite.

The size of the emoji image will be based on the sprite's size. Great for quick prototyping! 🧪

Custom Colors

You can also make pixel art that uses custom colors by creating a color palette and passing it as the third parameter to the spriteArt function.

Color palettes in p5play must be provided in JavaScript Object literal format. A simple JS object is like a dictionary. You can define a color for each letter you use in your pixel art. To create a color use the q5 color function which accepts RGB (red, green, blue) values or HEX color codes.

The easiest way to find colors is to use a color picker.

Sprite movement

Moving a sprite by directly editing its (x, y) coordinates will teleport it to the new position, without moving it through intermediate positions.

Try clicking around this code example.

If you want a sprite to physically interact with other sprites while it's moving, don't teleport it!

This bad example shows what happens if a sprite is teleported every time the q5.js draw function renders a frame.

All the other movement methods on this page change the sprite's velocity, aka vel, which is its rate of motion along the x and y axis.

vel is Q5.Vector, you can use any vector functions on it.

Restart this example to see the player sprite hit the block!

Yet, you may find it's more convenient to move a sprite by setting its direction and speed.

You can also set a sprite's direction using an angle value or direction name such as: 'up', 'down', 'left', 'right', 'upLeft', 'upRight', 'downLeft', 'downRight'.

The move function moves a sprite across a fixed distance. The direction and speed of the movement can be specified as parameters to the function or set separately, like in the previous example.

The moveTowards function moves a sprite towards a position, at a percentage of the distance to that position.

In this example, the player moves 10% of the distance to the mouse on every q5 draw call. Its speed, and the force it exerts on the block, is proportional to the distance it moves.

The moveTo function generates an impulse that moves a sprite to a position at a constant speed.

But note that if the sprite is acted on by a force like gravity or bumps into another sprite, its speed and direction will be affected and it may not reach the target position.

Any movement function that accepts an object with x and y properties could instead be called with (x, y) position numbers.

Hopefully the examples on this page helped you understand some of the sprite movement options available in p5play!

But, note that the move, moveTo, and moveTowards functions are imperative, they override a sprite's current motion, forcing it to move in a new direction. That may not always be what you want! Read the page on advanced sprite movement to learn how to move a sprite with respect to other forces acting on it, such as gravity.

Try it!

Try creating two sprites using the sprite constructor.

Collisions

To check for collisions use these functions inside the q5 draw function.

On the first frame that a sprite collides with another sprite, the collides function returns true.

While a sprite is colliding with another sprite, the colliding function returns the number of frames the collision has occurred for.

On the first frame after two sprites collided, the collided function returns true.

Overlaps

Sprites collide by default but they can also overlap!

By default sprites are drawn in the order they were created in.

Layer

You can change the draw order by editing a sprite's .layer property. Sprites with higher layer values get drawn on top of sprites with lower layer values.

For detecting overlaps, use these functions inside the q5 draw function.

On the first frame that a sprite overlaps with another sprite, the overlaps function returns true.

While a sprite is overlapping with another sprite, the overlapping function returns the number of frames the overlap has occurred for.

On the first frame after two sprites overlapped, the overlapped function returns true.

Note that physical interactions between sprites, including collisions and overlaps, can't be properly detected when a sprite is teleported, its position is directly changed!

The remove function deletes a sprite.

Try it!

Try making the blue sprite change to red only if it's overlapping with the red sprite.

Switch between overlaps and collides

When you set an overlap relationship between two sprites, they will no longer collide, but you can make them have a collision relationship again by using a collision function.

In this example, pressing the space key temporarily allows the player to ghost through the wall.

Sprite rotation

Directly changing the rotation property of a sprite will teleport it to the specified rotation angle.

Don't teleport a sprite if you want it to physically interact with other sprites while it's rotating!

All of the other rotation methods on this page work by changing the sprite's rotationSpeed.

Use the rotate function to rotate a sprite by an amount.

Rotation speed can be defined separately or as an optional second parameter.

Use the rotateTo function to rotate a sprite to an angle or to face a position. The rotateMinTo function changes the sign of the sprite's rotation speed if needed to rotate the sprite the minimum angular distance to face the destination angle. The "facing" angle, an optional third parameter, is the angle that the sprite should be at when facing the target position.

Try changing the facing angle from 0 to 90 in the code example. Then when you click, the long side of the sprite will rotate to face the mouse.

Use the rotateTowards function to rotate a sprite towards an angle or towards facing a position.

The optional second parameter is the tracking speed, a percent of the distance the sprite moves on each frame to the target rotation angle, 0.1 (10%) by default.

Use the offset property to move the sprite's physics body relative to its center.

When sprite.debug is true, the center of the sprite is marked with a small green crosshair. The center point is where the sprite's x and y coordinates are located. It is also the center of rotation.

Scaling

Changing sprite.scale will scale the sprite's collider and visual appearance by the specified amount.

Press a number key to see the sprite scale uniformly by that amount.

Click your mouse or touch tap to double the sprite's scale.

Press "x" or "y" to scale the sprite in that direction by a random amount. But note that if the sprite gets scaled unevenly, the image will get distorted and stay that way even when scaled uniformly again.

Physical attributes

Sprites have physical attributes that affect how they interact with the world. Take a look at the code examples to see these attributes in action.

Box2D quirks

p5play uses planck.js, a JS port of the Box2D physics engine. It generates realistic looking interactions, but also has some quirks you should be aware of.

In this code example, the ball has a bounciness of 1, each time the ball bounces, mathematically, it should return to its starting position. However, due to how Box2D resolves collisions, the ball bounces incrementally higher each time it hits the ground.

This full bounce interaction is impossible in real life, but could be an important element in a video game.

Here's a workaround that overrides the ball's y velocity after it collides with the ground.

In this example the block's color is red when it is colliding with the moving platform. Although you might expect the block to stay red while being lifted by the platform, it blinks between red and blue.

In real life when a person gets on an elevator and it rises, we would say that person was colliding with the elevator floor.

In Box2D however, when a collider is displaced by another collider, they constantly collide and separate from each other.

If you're trying to make a platformer game, colliding is not a reliable way to check if a sprite is standing on a platform. Check out the ➡️ platformer demo.

Advanced Movement

move functions are imperative, they override a sprite's velocities. But what if you want a sprite to respect other forces acting on it, such as gravity?

A bearing is the direction that needs to be followed to reach a destination. Changing a sprite's bearing won't imperatively change its movement direction.

Use applyForce with one input parameter, the amount of force, to have the force be applied at the sprite's bearing angle.

In this example, the drone has to overcome the force of gravity to fly. Make the drone fly, then let it fall, when upward force is applied to the drone again it'll gradually stop falling and start to fly!

The applyForceScaled function multiplies the force applied to the sprite by its mass.

You can use this function to give sprites their own gravity!

Both force functions can accept force as separate x and y components or as an amount, provided you set the sprite's bearing.

By default, force is applied to the sprite's center of mass. But the force functions can also accept a last input parameter, a position object with x and y properties that specifies the relative position of where force will be applied on the sprite.

Use the attractTo function to attract the sprite to a position by applying force. The position can be given as an object with x and y properties or as separate x and y parameters.

This example shows an electron orbiting the nucleus of an atom. (Note this visualization isn't realistic based on current scientific understanding, but it looks cool!)

Note that the advanced movement functions shown on this page will not wake sleeping sprites!

Torque is the force that causes rotation. Use applyTorque to non-imperatively affect the sprite's rotation.

In this example, the robot rolls slower going uphill than it does going downhill.

Chain Colliders

There are three different chain modes: vertex, distance, and line.

To use vertex mode, provide the Sprite constructor with an array of vertex arrays. Each vertex array should contain [x, y] coordinates. In these code examples the sprite's (x, y) position is highlighted by a small black square.

Try changing the vertexes of the chain sprite in the code example to make the ball stay on the floor!

To use distance mode, provide the Sprite constructor an (x, y) position and an array of distance arrays. These arrays should contain [x, y] distances relative to the previous vertex. The (x, y) position will be the first vertex in the chain.

Distance mode is best for creating super long chains.

Try adding 5 distances to make the ground roll up and down on a rocky ground chain.

To use line mode, provide the Sprite constructor an (x,y) position and a list of line lengths and angles. Each angle is relative to the previous line's angle.

It's best to use line mode for small and/or symmetrical chains.

Note that the line mode chain's (x, y) position is located at the average of all its vertices, which may not be a point on the chain.

Try changing the lengths of these lines and their angles!

Polygon Colliders

Regular polygons can be created by providing the Sprite constructor with a side length and the name of the polygon.

Here are the names you can use: triangle, square, pentagon, hexagon, septagon, octagon, enneagon, decagon, hendecagon, and dodecagon.

If the start and end of a chain is at the same point and the resulting shape is convex, it automatically becomes a polygon!

You can force a convex polygon to be a chain by setting sprite.shape = 'chain'

Any polygon or chain with a closed shape is center positioned.

Here's the code for making a regular star with five points.

Note that because the star is a concave shape it can't have a polygon collider.

Now you can see how the tumbler demo on the p5play homepage was made!

Closed chains are empty on the inside and they can act as a container for many smaller sprites.

Note that closed chain colliders aren't so good at being dynamic colliders.

This is a limitation of the Box2D physics engine that p5play uses. See the "Combo Colliders" page to learn how to create concave colliders from multiple convex colliders.

Movement Sequencing

You can use the await keyword inside an async function to wait for a movement to finish before continuing with the next movement. This is useful for making a sprite move in a sequence.

The delay function can be used to wait for a specified number of milliseconds. 1000 milliseconds is equal to 1 second.

The move, moveTo, rotate, rotateTo, and rotateMinTo functions all return a Promise that resolves to true when the movement is finished.

But, if the sprite's movement is interrupted by a new movement or a collision that significantly changes the sprite's trajectory, the promise will resolve to false.

If you want a sprite to follow another sprite, you may be tempted to use moveTo repeatedly, without waiting for the sprite to reach its destination. But for better performance, change the sprite's direction. Use the angleTo function, which gets the angle between a sprite and a position.

In this example, the q5 dist function is used to calculate the distance between the player and its ally.