# The magic of compound objects with Box2D

You can call it complex shapes, compound shapes, complex objects, compound objects or even poisoned underpants, but you all want to create complex “things” with Box2D.

Despite the “complex” word, it’s very easy to create one.

You just have to add multiple shapes to a body.

If you followed my latest Box2D tutorials, you will find the whole code I am going to show you very familiar, with some exceptions I will explain.

But first let’s take a look at what I am going to create: a perfect tile based maze, made with small squares representing the tiles and managed as a single object.

Here it is: if you drag the maze, you will see it’s a single object made (compound) with small tiles – the real objects, used as primitives.

Here it is the code:

```package {
import flash.display.Sprite;
import flash.events.Event;
import Box2D.Dynamics.*;
import Box2D.Collision.*;
import Box2D.Collision.Shapes.*;
import Box2D.Common.Math.*;
import Box2D.Dynamics.Joints.*;
import flash.events.MouseEvent;
public class HelloWorld extends Sprite {
var body:b2Body;
var mouseJoint:b2MouseJoint;
var m_world:b2World;
var m_iterations:int=10;
var m_timeStep:Number=1.0/30.0;
var maze:Array = [[1,1,1,1,1,1,1,1,1],[1,0,0,0,0,0,0,0,1],[1,1,1,1,1,1,1,0,1],[1,0,0,0,1,0,0,0,1],[1,0,1,0,1,0,1,1,1],[1,0,1,0,1,0,0,0,1],[1,0,1,1,1,1,1,0,1],[1,0,0,0,0,0,0,0,1],[1,1,1,1,1,1,1,1,1]];
public function HelloWorld() {
var worldAABB:b2AABB = new b2AABB();
worldAABB.lowerBound.Set(-100.0, -100.0);
worldAABB.upperBound.Set(100.0, 100.0);
var gravity:b2Vec2=new b2Vec2(0.0,10.0);
var doSleep:Boolean=true;
m_world=new b2World(worldAABB,gravity,doSleep);
// debug draw start
var m_sprite:Sprite;
m_sprite = new Sprite();
var dbgDraw:b2DebugDraw = new b2DebugDraw();
var dbgSprite:Sprite = new Sprite();
dbgDraw.m_sprite=m_sprite;
dbgDraw.m_drawScale=30;
dbgDraw.m_alpha = 1;
dbgDraw.m_fillAlpha=0.7;
dbgDraw.m_lineThickness=1;
m_world.SetDebugDraw(dbgDraw);
// debug draw end
var bodyDef:b2BodyDef;
var boxDef:b2PolygonDef;
// lower static object
bodyDef = new b2BodyDef();
bodyDef.position.Set(8.5, 13);
boxDef = new b2PolygonDef();
boxDef.SetAsBox(8.5, 0.5);
boxDef.friction=0.3;
boxDef.density=0;
body=m_world.CreateBody(bodyDef);
body.CreateShape(boxDef);
body.SetMassFromShapes();
// objects
bodyDef = new b2BodyDef();
bodyDef.position.Set(1, 3);
body = m_world.CreateBody(bodyDef);
for (var j=0; j<9; j++) {
for (var i=0; i<9; i++) {
if (maze[j][i]==1) {
boxDef = new b2PolygonDef();
boxDef.SetAsOrientedBox(0.5,0.5,new b2Vec2(i, j), 0);
boxDef.density=1.0;
boxDef.friction=0.5;
boxDef.restitution=0.2;
body.CreateShape(boxDef);
}
}
}
body.SetMassFromShapes();
}
public function createMouse(evt:MouseEvent):void {
var body:b2Body=GetBodyAtMouse();
if (body) {
var mouseJointDef:b2MouseJointDef=new b2MouseJointDef;
mouseJointDef.body1=m_world.GetGroundBody();
mouseJointDef.body2=body;
mouseJointDef.target.Set(mouseX/30, mouseY/30);
mouseJointDef.maxForce=30000;
mouseJointDef.timeStep=m_timeStep;
mouseJoint=m_world.CreateJoint(mouseJointDef) as b2MouseJoint;
}
}
public function destroyMouse(evt:MouseEvent):void {
if (mouseJoint) {
m_world.DestroyJoint(mouseJoint);
mouseJoint=null;
}
}
private var mousePVec:b2Vec2 = new b2Vec2();
public function GetBodyAtMouse(includeStatic:Boolean=false):b2Body {
var mouseXWorldPhys = (mouseX)/30;
var mouseYWorldPhys = (mouseY)/30;
mousePVec.Set(mouseXWorldPhys, mouseYWorldPhys);
var aabb:b2AABB = new b2AABB();
aabb.lowerBound.Set(mouseXWorldPhys - 0.001, mouseYWorldPhys - 0.001);
aabb.upperBound.Set(mouseXWorldPhys + 0.001, mouseYWorldPhys + 0.001);
var k_maxCount:int=10;
var shapes:Array = new Array();
var count:int=m_world.Query(aabb,shapes,k_maxCount);
var body:b2Body=null;
for (var i:int = 0; i < count; ++i) {
if (shapes[i].GetBody().IsStatic()==false||includeStatic) {
var tShape:b2Shape=shapes[i] as b2Shape;
var inside:Boolean=tShape.TestPoint(tShape.GetBody().GetXForm(),mousePVec);
if (inside) {
body=tShape.GetBody();
break;
}
}
}
return body;
}
public function Update(e:Event):void {
m_world.Step(m_timeStep, m_iterations);
if (mouseJoint) {
var mouseXWorldPhys=mouseX/30;
var mouseYWorldPhys=mouseY/30;
var p2:b2Vec2=new b2Vec2(mouseXWorldPhys,mouseYWorldPhys);
mouseJoint.SetTarget(p2);
}
}
}
}
```

You can find the maze at line 16 (yes, I did not create it dynamically, feel free to do it if you want), and now let's look at the difference between a normal and a compound object.

A normal object, like the green static floor, after the `CrateShape` method at line 51, has a `setMassFromShapes` that finalizes the object itself.

If you look at the maze, inside the two cycles at lines 57-58, I only have `CreateShape` calls while a single `setMassFromShapes` is called after I completed the cycles.

This way, I am getting all objects merged in one big, compound, object.

And that's all...

215 GAME PROTOTYPES EXPLAINED WITH SOURCE CODE
// 1+2=3
// 10000000
// 2 Cars
// 2048
// Avoider
// Ballz
// Block it
// Blockage
// Bloons
// Boids
// Bombuzal
// Breakout
// Bricks
// Columns
// CubesOut
// Dots
// DROP'd
// Dudeski
// Eskiv
// Filler
// Fling
// Globe
// HookPod
// Hundreds
// InkTd
// Iromeku
// Lumines
// Magick
// MagOrMin
// Maze
// Memdot
// Nano War
// Nodes
// o:anquan
// Ononmin
// Pacco
// Phyballs
// Platform
// Poker
// Pool
// Poux
// Pudi
// qomp
// Racing
// Renju
// SameGame
// Security
// Sling
// Slingy
// Sokoban
// Splitter
// Sproing
// Stack
// Stairs
// Stringy
// Sudoku
// Tetris
// Threes
// Toony
// Turn
// TwinSpin
// vvvvvv
// Wordle
// Worms
// Yanga
// Zhed
// zNumbers