Last modified: Sat, 5 Mar 2011
Refresh

Getting started

• What is ExtremePhysics?

• ExtremePhysics classes

• Initializing ExtremePhysics

• Creating a world

• Creating a static body

• Creating a dynamic body

• Circle shapes

• Polygon shapes

• Simulating

• Destroying ExtremePhysics resources

What is ExtremePhysics?

ExtremePhysics is a 2D rigid body simulation engine designed for Game Maker. The DLL is written in C++.

ExtremePhysics classes

ExtremePhysics uses a number of classes (types of resources):

• World: This class connects the other classes. You can create multiple worlds but most of the time one world is all you need.

• Polygon: Polygons are used to define the vertices of polygon shapes.

• Body: A body is the equivalent an object in Game Maker. Usually every object in Game Maker is associated with one body.

• Shape: Shapes are used to define the shape of a body. There are three types of shapes: box shapes, circle shapes and polygon shapes. One body can consist of multiple shapes.

• Force: Forces can be added to bodies to simulate some effects, e.g. a rocket engine.

• Contact: This is a special class. You can't create or destroy contacts, because contacts are created and destroyed automatically by ExtremePhysics during the simulation when different shapes collide. Contacts can be used to detect collisions.

• Joints: Joints are used to connect bodies. There are multiple types of joints.

• View: Views can be used to speed up the simulation for games that use views. Parts of the world that are out of view can be put to sleep to save processing time.

This image shows how the classes are connected:

Initializing ExtremePhysics

If you are using the DLL (instead of the extension), you have to initialize ExtremePhysics before you can use it. This isn't very hard:

// If the name of the DLL file is ExtremePhysics.dll,
// this should work:
extremephysics_init();

// If the DLL is not in the working directory,
// you can use this instead:
extremephysics_init("path/to/ExtremePhysics.dll");

Note that the game start event is executed after the create event, therefore it's a good idea to create an empty room (room_gamestart) with one object (obj_gamestart) that executes this code before going to the next room, to make sure this code is executed before anything else.

If you forget to initialize the DLL, you will get an error message when you try to use the scripts ("undefined variable global.define_ep_functionname").

Creating a world

Creating a world is easy:

global.world = ep_world_create();

After creating the world, you should change the settings of the world:

ep_world_set_settings(global.world,1,20,10,0.1,0.5,0,0.5,1);

I will explain the meaning of this code in a separate tutorial.

Creating a static body

There are two kinds of bodies: static and dynamic. Static bodies can move, but their movement isn't influenced by other bodies. The movement of dynamic bodies can be influenced by other bodies (even static bodies). Static bodies are used for things that can not be moved by other bodies (e.g. the ground, walls, platforms that move at a fixed speed).

I will show you how to create a simple static box. First you have to create the body:

body = ep_body_create_static(global.world);
// global.world: the id of the world you created.

However, without any shapes the body isn't very useful. The next step is to add a box shape:

shape1 = ep_shape_create_box(global.world,body,32,32,0,0,0,1);
// global.world: the id of the world.
// body: the id of the body you created.
// 32,32: the size of the box.
// 0,0,0: the relative coordinates of the shape (x,y,rot).
// 1: the density of the box (not used for static bodies).

This code will create a static box, but the box won't collide with anything. The collision system ExtremePhysics uses takes three values: collision mask 1, collision mask 2 and group. Collision mask 1 and collision mask 2 are 32-bit unsigned integers. Collision mask 1 stores the layers the shape belongs to, collision mask 2 stores the layers the shape should collide with. Every bit is one layer, so you can use up to 32 layers. If collision mask 1 matches collision mask 2 or collision mask 2 matches collision mask 1, the bodies will collide. But if they are in the same group (not group 0), they will never collide.

// pseudo-code
if (body1.mask1 & body2.mask2 != 0 or body1.mask2 & body2.mask1 != 0) and (body1.group == 0 or body1.group != body2.group) {
    // collision
} else {
    // no collision
}

Groups are useful if your game uses lots of small groups of bodies that can't collide, like cars (the wheels shouldn't collide with the car, otherwise they can't overlap).

ep_shape_set_collision(global.world,body,shape1,1,1,0);
// 1: collision mask 1 (binary 00000000 00000000 00000000 00000001).
// 1: collision mask 2 (binary 00000000 00000000 00000000 00000001).
// 0: group (0 means no group).

The next step is to change the material of the box:

ep_shape_set_material(global.world,body,shape1,0.5,0.4,0,0);
// 0.5: coefficient of restitution.
// 0.4: friction.
// 0: normal surface velocity.
// 0: tangential surface velocity.

Finally the box is moved to the correct position:

ep_body_set_position(global.world,body,x,y,degtorad(image_angle));
// x: x coordinate of the body.
// y: y coordinate of the body.
// degtorad(image_angle): rotation of the body, in radians.

Creating a dynamic body

Creating dynamic bodies is almost the same as creating static bodies. There is one extra argument for dynamic bodies: norotation. If norotation is true, the rotation of the body will not be influenced by other bodies (because the moment of inertia of the body is infinite).

body = ep_body_create_dynamic(global.world,false);
// false: this body can rotate.

You have to set the center of mass, mass and moment of inertia of the body before you can use it. The easiest way to do this is calling ep_body_calculate_mass. This function will calculate the center of mass, mass and moment of inertia of the body based on the shapes you have added to the body.

// call this function after adding the shapes:
ep_body_calculate_mass(global.world,body);

Circle shapes

You can create circle shapes in the same way you create box shapes:

shape1 = ep_shape_create_circle(global.world,body,32,0,0,0,1);
// 32: the radius of the circle.
// 0,0,0: the relative coordinates of the shape (x,y,rot).
// 1: the density of the circle (not used for static bodies).

Polygon shapes

Creating polygon shapes is more complicated, because you have to create a polygon first. A polygon can be used by multiple bodies, so usually you can create all polygons immediately after creating the world.

global.poly_triangle1 = ep_polygon_create(global.world,3);
// 3: number of vertices.
ep_polygon_set_vertex(global.world,global.poly_triangle1,0,-10,-10);
// 0: first vertex.
// -10,-10: coordinates of the vertex.
ep_polygon_set_vertex(global.world,global.poly_triangle1,1,+10,+10);
// 1: second vertex.
// +10,+10: coordinates of the vertex.
ep_polygon_set_vertex(global.world,global.poly_triangle1,2,-10,+10);
// 2: third vertex.
// -10,+10: coordinates of the vertex.
ep_polygon_initialize(global.world,global.poly_triangle1);

There are two things you have to take in mind:

• Vertices have to be declared in clockwise order (in a left-handed coordinate system).

• All polygons have to be convex. If a body is concave you have to create multiple convex polygons. You can use multipolygons to accomplish that.

shape1 = ep_shape_create_polygon(global.world,body,global.poly_triangle1,0,0,0,1);
// global.poly_triangle1: the id of the polygon.
// 0,0,0: the relative coordinates of the shape (x,y,rot).
// 1: the density of the polygon (not used for static bodies).

Simulating

You have to call ep_world_update_contacts and ep_world_simulate_step to simulate one step. Usually this is done in the end step event of the controller.

ep_world_update_contacts(global.world);
ep_world_simulate_step(global.world);

After simulating a step you have to update the position and orientation of the objects in Game Maker to see the results of the simulation.

x = ep_body_get_x(global.world,body);
y = ep_body_get_y(global.world,body);
image_angle = radtodeg(ep_body_get_rot(global.world,body));

Destroying ExtremePhysics resources

When you destroy an object in Game Maker, you have to destroy the body too:

ep_body_destroy(global.world,body);

Don't forget to destroy the world when the player leaves the room:

// room end event
ep_world_destroy(global.world)

Good luck!

Comments

ep_body_set_gravity(global.world,body,0,y+100);

xx=ep_body_get_xvel_center(global.world, argument0)
yy=ep_body_get_yvel_center(global.world, argument0)
arot=ep_body_get_rotvel(global.world, argument0)
if xx !=0 then xx*=floor_friction
if yy !=0 then yy*=floor_friction
if arot != 0 then arot*=floor_friction
ep_body_set_velocity_center(global.world, argument0, xx,yy,arot)

ep_world_set_settings(global.world,1,20,10,0.1,0.5,0.1,0.5,1);

ep_world_set_settings(global.world,1,20,10,0.1,0.5,0.1,0.5,1);

Write a comment