# Corona – Physics

Corona has a nifty physics engine built in. The physics engine is used to simulate the interactions of objects using real world effects like gravity and motion. Elements, called “bodies”, can properties like density, friction and bounciness, which make them behave like real objects in the real world. Imagine you threw a ball. It might fly through the air while gravity pulled it toward the earth. Then it might bounce when it hit the ground and bounce again when it a wall. If you wanted to create a similar effect in an app the physics engine would help you do this and make it look realistic.

### Using physics in Corona

Using physics in Corona is surprisingly easy and straight forward. The first step is to import the physics class and turn the physics engine on.

```local physics = require("physics")
physics.start()```

The first line import the physics engine and the second turns it on. The first line stores a reference to the physics engine in a variable named “physics”, we’ll use this to talk to the physics engine. Notice the second line uses the “physics” variable to turn the engine on. As we go you’ll see we’ll use the name “physics” to create physics “bodies” and set other options having to do with the physics environment.

Create a body

Next create a display object of some kind. This can be an image or a shape, then create a physics “body” from that object. The body is controlled by the physics environment and essentially takes over the display object moving it as it might move with the effects of gravity and bumping into other “bodies”.

Here’s a simple example that creates an image turns it into a physics body.

```local box = display.newImage("box.png")
physics.addBody( box, "dynamic", { density=1.0, friction=0.3, bounce=0.65 } )```

Here we call physics.addBody() with three parameters. The first, a display object to create the body from, box in this example. The second sets the type of object this will, “dynamic” in this case. “Dynamic” objects can move around and bump into other object. Last is a table containing options for the object, density, friction and bounce in this example.

• density – the weight or mass of an object
• friction – how much energy the object loses over time
• bounce – the amount of energy the object retains when bounces off another object

Try it for yourself

Try this out for yourself. Follow the instructions below.

1. Create a folder to hold your project.
2. Create a new text file and save it into your folder with the name main.lua.
```local physics = require("physics")
physics.setDrawMode( "debug" )
physics.start()```

Here I imported the physics library and set some options. I set the draw mode to debug. This will display simple shapes for your physics objects. Second I started the physics engine running.

Now add a shape. Add a small image to your folder to use a physics object. Make this a square or a circle about 20px in diameter.

```local ball = display.newImage("ball.png")
ball.x = 160
ball.y = 30

Here you imported your image and made a display object from it, with the name “ball”. Then positioned the ball at the top center of the screen. Then you created a physics “body” from your display object. This is a “dynamic” object so it will move around. I added the “radius” property and set the value to the radius of the ball image. Since my ball was 20px I used 10 as the radius. Adding radius makes the “body” circular.

Test your project. At this point the ball should fall down the screen as if it were pulled by the force of gravity. The same thing would happen if you dropped a real ball. Of course a real ball would not fall forever it would hit the ground at some point.

Make a static body

Next we’ll create a ground plane.

```local floor = display.newRect(0, 0, 320, 10)
floor.x = 160
floor.y = 475
floor:setFillColor( 255, 0, 0 )
physics.addBody( floor, "static", {density=1.0, friction=0.3 } )```

Rather than using an image this time I created a rectangle shape object, 320px wide and 10px tall. The new shape is named “floor”.  Next we positioned the floor at the bottom center of the screen. Then give it a fill color of red. Last we create a new “body” from the floor shape. Here the type is “static”. Static shapes don’t move.

Test your project again. This time the ball falls and bounces off the ground. Change the bounce value assigned to the ball body, notice the change.

Gravity

Change the gravity in your physics world with physics.setGravity(x,y). Gravity is a constant force that pulls object in one direction. Add the following to your main.lua.

`physics.setGravity(0,0)`

Test your project again, notice the ball goes nowhere. This time there is no gravity. We can use this setting to simulate a top down view. Try out a few different values for the x and y of gravity. Set this back to 0 and 0 when you’re satisfied you understand what is happening with gravity.

```local ceiling = display.newRect(0, 0, 320, 10)
ceiling.x = 160
ceiling.y = 5
ceiling:setFillColor( 255, 0, 0 )
physics.addBody( ceiling, "static", {density=1.0, friction=0.3 } )

local left = display.newRect(0, 0, 10, 480)
left.x = 5
left.y = 240
left:setFillColor( 255, 0, 0 )
physics.addBody( left, "static", {density=1.0, friction=0.3 } )

local right = display.newRect(0, 0, 10, 480)
right.x = 315
right.y = 240
right:setFillColor( 255, 0, 0 )
physics.addBody( right, "static", {density=1.0, friction=0.3 } )```

Here I’ve added three more boxes like the floor. These make up the left and right walls and the ceiling.

Test your project again. You should see the new walls and there should be a wall on each edge of the screen.

Velocity

Next we’ll make the ball move by tapping the screen. With each tap we’ll give the ball some linear velocity. That’s velocity in a straight line.

```local function onTouch(event)
local x = ball.x - event.x
local y = ball.y - event.y
ball:setLinearVelocity( x, y )
end

Here I created a function, onTouch. This function is triggered when the screen is touched. The event object passed to the function contains an x and a y position of where the touch occurred. The first to lines in the function the difference between the touch x and y and the ball x and y. The last line calls the setLinearVelocity method of ball and uses the two values to push the ball away from were you touch the screen.

The line below the function adds an event listener to the screen. This is what will trigger the event when a touch occurs.

Test your project again. This time the ball should sit still until you touch the screen. When you touch the screen the ball should move way from the point where the touch occurred bouncing off the walls as it moves.

Here’s a few things to try for yourself.

1. Try different values for gravity
2. Try out different values for density, friction and bounce for the ball
3. Try removing the line physics.setDrawMode( “debug” )
4. Try changing changing from debug to hybrid physics.setDrawMode( “hybrid” )