Prototype of a Flash game like Meeblings

You should all known Meeblings and the sequel, Meeblings 2.

Meeblings

You have to help the Meeblings (cute creatures I’d love to burn alive) reaching the exit using some special abilities.

One of such abilities attracts Meeblings when you click and hold the mouse on a special Meebling.

In the prototype you are about to see, derived from the basic HelloWorld Box2D example, there are 10 randomly placed balls with different masses.

When you click and hold anywhere on the stage, every ball in a 4 meters radius (read this post and this post too if you don’t know how to convert meters to pixels) will be attracted towards the mouse pointer.

The more the distance, the stronger the attraction. Read more

July 1, 2009 | Filed Under Actionscript 3, Box2D, Flash, Game design | 5 Comments 

Play Mazeroll, my latest Box2D game

After SamePhysics, I made another Box2D game called Mazeroll.

Mazeroll

You have to drag a maze to made two circles touch, collecting as much red orbs as you can, before time reaches zero.

You can find some clues about the making of this game reading The magic of compound objects with Box2D and Perfect maze generation – tile based version.

I simply put together these two concept and added some gameplay.

As you can see there are some in-game banners, and there is room for two more banners in the rotation, so starting from June 29, when the game is supposed to have been widely published, I will insert two (and only two) more ** LIFETIME ** banners for as low as $100 per banner.

Drop me an email at info[at]emanueleferonato.com if you want to be one of the lucky two people that will get these banners.

June 20, 2009 | Filed Under Actionscript 3, Box2D, Flash, Game design, Monetize | 11 Comments 

Understanding how Box2D manages boundaries

Sometimes you may need to determine if your Box2D object has fallen off the screen. This mostly happens in games, where you are going to build something and some pieces may fall down, but obviously you can extend the concept to any application you may write.

There are two “obvious” ways to do it:

1) Checking x and y coordinates of every object… this is the “old school” method… very easy to determine which object is in the visible area and which one got lost into the deep nowhere… but we live in “Web 2.0″ age, and this method is “Web 0.1 pre alpha”…

2) Using sensors placed in the right spots and check if an object touches them… in this case this means the object is outside the screen. Yuou can read more about this method at Erase Box: the tutorial post. Very cool solution, but not what I am going to explain.

3) Using the b2BoundaryListener class – Box2D has a class called b2BoundaryListener that handles objects outside the boundaries. Let’s see some code: Read more

May 18, 2009 | Filed Under Actionscript 3, Box2D, Flash | 10 Comments 

Two ways to make Box2D cars

I am showing you two ways to make cars with Box2d, with source codes included

These are examples I found on the web – I will make my ones later – you can find interesting in order to make cars using Box2D.

Top Down Car Simulation

Making a top down game in Box2D is not that different than making a side view game… you just don’t have to set gravity.

Here it is a top-down racing game

And this is the script to handle it

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209

import Box2D.Collision.*;// bounding box of our world
import Box2D.Common.Math.*;// for vector(define gravity)
import Box2D.Dynamics.*;// define bodies and define world
import Box2D.Dynamics.Joints.*;
import Box2D.Collision.Shapes.*;// define our shapes
import flash.display.*;// sprite class
 
const MAX_STEER_ANGLE:Number = Math.PI/3;
const STEER_SPEED = 1.5;
const SIDEWAYS_FRICTION_FORCE:Number = 10;
const HORSEPOWERS:Number = 40
const CAR_STARTING_POS:b2Vec2 = new b2Vec2(10,10);
 
const leftRearWheelPosition:b2Vec2 = new b2Vec2(-1.5,1.90);
const rightRearWheelPosition:b2Vec2 = new b2Vec2(1.5,1.9);
const leftFrontWheelPosition:b2Vec2 = new b2Vec2(-1.5,-1.9);
const rightFrontWheelPosition:b2Vec2 = new b2Vec2(1.5,-1.9);
 
var engineSpeed:Number =0;
var steeringAngle:Number = 0
 
var myWorld:b2World;
 
var worldBox:b2AABB = new b2AABB();
worldBox.lowerBound.Set(-100,-100);
worldBox.upperBound.Set(100,100);
 
myWorld = new b2World(worldBox, new b2Vec2(0,0) , true);
 
//Create some static stuff
var staticDef = new b2BodyDef();
staticDef.position.Set(5,20);
var staticBox = new b2PolygonDef();
staticBox.SetAsBox(5,5);
myWorld.CreateBody(staticDef).CreateShape(staticBox);
staticDef.position.x = 25;
myWorld.CreateBody(staticDef).CreateShape(staticBox);
staticDef.position.Set(15, 24);
myWorld.CreateBody(staticDef).CreateShape(staticBox);
 
 
// define our body
var bodyDef:b2BodyDef = new b2BodyDef();
bodyDef.linearDamping = 1;
bodyDef.angularDamping = 1;
bodyDef.position = CAR_STARTING_POS.Copy()
 
var body:b2Body = myWorld.CreateBody(bodyDef);
body.SetMassFromShapes();
 
var leftWheelDef:b2BodyDef = new b2BodyDef();
leftWheelDef.position = CAR_STARTING_POS.Copy();
leftWheelDef.position.Add(leftFrontWheelPosition);
var leftWheel:b2Body = myWorld.CreateBody(leftWheelDef);
 
var rightWheelDef:b2BodyDef = new b2BodyDef();
rightWheelDef.position = CAR_STARTING_POS.Copy();
rightWheelDef.position.Add(rightFrontWheelPosition);
var rightWheel:b2Body = myWorld.CreateBody(rightWheelDef);
 
var leftRearWheelDef:b2BodyDef = new b2BodyDef();
leftRearWheelDef.position = CAR_STARTING_POS.Copy();
leftRearWheelDef.position.Add(leftRearWheelPosition);
var leftRearWheel:b2Body = myWorld.CreateBody(leftRearWheelDef);
 
var rightRearWheelDef:b2BodyDef = new b2BodyDef();
rightRearWheelDef.position = CAR_STARTING_POS.Copy();
rightRearWheelDef.position.Add(rightRearWheelPosition);
var rightRearWheel:b2Body = myWorld.CreateBody(rightRearWheelDef);
 
// define our shapes
var boxDef:b2PolygonDef = new b2PolygonDef();
boxDef.SetAsBox(1.5,2.5);
boxDef.density = 1;
body.CreateShape(boxDef);
 
//Left Wheel shape
var leftWheelShapeDef = new b2PolygonDef();
leftWheelShapeDef.SetAsBox(0.2,0.5);
leftWheelShapeDef.density = 1;
leftWheel.CreateShape(leftWheelShapeDef);
 
//Right Wheel shape
var rightWheelShapeDef = new b2PolygonDef();
rightWheelShapeDef.SetAsBox(0.2,0.5);
rightWheelShapeDef.density = 1;
rightWheel.CreateShape(rightWheelShapeDef);
 
//Left Wheel shape
var leftRearWheelShapeDef = new b2PolygonDef();
leftRearWheelShapeDef.SetAsBox(0.2,0.5);
leftRearWheelShapeDef.density = 1;
leftRearWheel.CreateShape(leftRearWheelShapeDef);
 
//Right Wheel shape
var rightRearWheelShapeDef = new b2PolygonDef();
rightRearWheelShapeDef.SetAsBox(0.2,0.5);
rightRearWheelShapeDef.density = 1;
rightRearWheel.CreateShape(rightRearWheelShapeDef);
 
body.SetMassFromShapes();
leftWheel.SetMassFromShapes();
rightWheel.SetMassFromShapes();
leftRearWheel.SetMassFromShapes();
rightRearWheel.SetMassFromShapes();
 
var leftJointDef:b2RevoluteJointDef = new b2RevoluteJointDef();
leftJointDef.Initialize(body, leftWheel, leftWheel.GetWorldCenter());
leftJointDef.enableMotor = true;
leftJointDef.maxMotorTorque = 100;
 
var rightJointDef = new b2RevoluteJointDef();
rightJointDef.Initialize(body, rightWheel, rightWheel.GetWorldCenter());
rightJointDef.enableMotor = true;
rightJointDef.maxMotorTorque = 100;
 
var leftJoint:b2RevoluteJoint = b2RevoluteJoint(myWorld.CreateJoint(leftJointDef));
var rightJoint:b2RevoluteJoint = b2RevoluteJoint(myWorld.CreateJoint(rightJointDef));
 
var leftRearJointDef:b2PrismaticJointDef = new b2PrismaticJointDef();
leftRearJointDef.Initialize(body, leftRearWheel, leftRearWheel.GetWorldCenter(), new b2Vec2(1,0));
leftRearJointDef.enableLimit = true;
leftRearJointDef.lowerTranslation = leftRearJointDef.upperTranslation = 0;
 
var rightRearJointDef:b2PrismaticJointDef = new b2PrismaticJointDef();
rightRearJointDef.Initialize(body, rightRearWheel, rightRearWheel.GetWorldCenter(), new b2Vec2(1,0));
rightRearJointDef.enableLimit = true;
rightRearJointDef.lowerTranslation = rightRearJointDef.upperTranslation = 0;
 
myWorld.CreateJoint(leftRearJointDef);
myWorld.CreateJoint(rightRearJointDef);
 
 
// debug draw
var dbgDraw:b2DebugDraw = new b2DebugDraw();
dbgDraw.m_sprite = new Sprite();
addChild(dbgDraw.m_sprite);
dbgDraw.m_drawScale = 20.0;
dbgDraw.m_fillAlpha = 0.3;
dbgDraw.m_lineThickness = 1.0;
dbgDraw.m_drawFlags = b2DebugDraw.e_shapeBit |b2DebugDraw.e_centerOfMassBit;
myWorld.SetDebugDraw(dbgDraw);
 
 
//========== FUNCTIONS ==========
 
//This function applies a "friction" in a direction orthogonal to the body's axis.
function killOrthogonalVelocity(targetBody:b2Body){
	var localPoint = new b2Vec2(0,0);
	var velocity:b2Vec2 = targetBody.GetLinearVelocityFromLocalPoint(localPoint);
 
	var sidewaysAxis = targetBody.GetXForm().R.col2.Copy();
	sidewaysAxis.Multiply(b2Math.b2Dot(velocity,sidewaysAxis))
 
	targetBody.SetLinearVelocity(sidewaysAxis);//targetBody.GetWorldPoint(localPoint));
}
 
stage.addEventListener(KeyboardEvent.KEY_DOWN, keyPressed_handler);
stage.addEventListener(KeyboardEvent.KEY_UP, keyReleased_handler);
 
function keyPressed_handler(e:KeyboardEvent) {
	if(e.keyCode == Keyboard.UP){
		body.WakeUp();
		engineSpeed = -HORSEPOWERS;
	}
	if(e.keyCode == Keyboard.DOWN){
		engineSpeed = HORSEPOWERS;
	}
	if(e.keyCode == Keyboard.RIGHT){
		steeringAngle = MAX_STEER_ANGLE
	}
	if(e.keyCode == Keyboard.LEFT){
		steeringAngle = -MAX_STEER_ANGLE
	}
}
 
function keyReleased_handler(e:KeyboardEvent){
	if(e.keyCode == Keyboard.UP || e.keyCode == Keyboard.DOWN){
		engineSpeed = 0;
	} 
	if(e.keyCode == Keyboard.LEFT || e.keyCode == Keyboard.RIGHT){
		steeringAngle = 0;
	}
}
 
addEventListener(Event.ENTER_FRAME, Update, false, 0 , true);
 
function Update(e:Event):void {
	myWorld.Step(1/30, 8);
	killOrthogonalVelocity(leftWheel);
	killOrthogonalVelocity(rightWheel);
	killOrthogonalVelocity(leftRearWheel);
	killOrthogonalVelocity(rightRearWheel);
 
	//Driving
	var ldirection = leftWheel.GetXForm().R.col2.Copy();
	ldirection.Multiply(engineSpeed);
	var rdirection = rightWheel.GetXForm().R.col2.Copy()
	rdirection.Multiply(engineSpeed);
	leftWheel.ApplyForce(ldirection, leftWheel.GetPosition());
	rightWheel.ApplyForce(rdirection, rightWheel.GetPosition());
 
	//Steering
	var mspeed:Number;
	mspeed = steeringAngle - leftJoint.GetJointAngle();
	leftJoint.SetMotorSpeed(mspeed * STEER_SPEED);
	mspeed = steeringAngle - rightJoint.GetJointAngle();
	rightJoint.SetMotorSpeed(mspeed * STEER_SPEED);
}

more information at the official forum thread

Truck car game

This is a truck car game, this concept was very popular a couple of years ago.

The truck is made using various joints, such as revolute joints and prismatic joints.

Here it is the source code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264

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.*;
 
   public class TruckGame extends Sprite {
 
      public const ITERATIONS      : int       = 30;
      public const TIME_STEP       : Number    = 1.0/60.0;
      public const SCREEN_WIDTH    : int       = 800;
      public const SCREEN_HEIGHT   : int      = 500;
      public const DRAW_SCALE      : Number   = 50;
 
      private var world    : b2World;
      private var cart    : b2Body;
      private var wheel1    : b2Body;
      private var wheel2    : b2Body;
      private var axle1   : b2Body;
      private var axle2   : b2Body;
      private var motor1   : b2RevoluteJoint;
      private var motor2   : b2RevoluteJoint;
      private var spring1   : b2PrismaticJoint;
      private var spring2   : b2PrismaticJoint;
 
      private var screen   : Sprite;
      private var input   : Input;
 
 
      public function TruckGame() : void {
 
         // create the drawing screen //
         screen = new Sprite();
         screen.scaleY = -1;
         screen.y = SCREEN_HEIGHT;
         addChild(screen);
 
         // initialize input object //
         input = new Input(this);
 
         // add main loop event listener //
         addEventListener(Event.ENTER_FRAME, update, false, 0, true);
 
         init();
 
      }
 
      private function init() : void {
 
         // create world //
         var worldAABB:b2AABB = new b2AABB();
 
         worldAABB.lowerBound.Set(-200, -100);
         worldAABB.upperBound.Set(200, 200);
 
         world = new b2World(worldAABB, new b2Vec2(0, -10.0), true);
 
 
         // allow debug drawing //
         var debugDraw : b2DebugDraw = new b2DebugDraw();
         debugDraw.m_sprite          = screen;
         debugDraw.m_drawScale       = DRAW_SCALE;
         debugDraw.m_fillAlpha       = 0.1;
         debugDraw.m_lineThickness    = 2.0;
         debugDraw.m_drawFlags       = 1;
 
         world.SetDebugDraw(debugDraw);
 
 
         // temporary variables for adding new bodies //
         var i               : int;
         var body             : b2Body;
         var bodyDef          : b2BodyDef;
         var boxDef             : b2PolygonDef;
         var circleDef          : b2CircleDef;
         var revoluteJointDef   : b2RevoluteJointDef;
         var prismaticJointDef   : b2PrismaticJointDef;
 
 
         // add the ground //
         bodyDef = new b2BodyDef();
         bodyDef.position.Set(0, 0.5);
 
         boxDef = new b2PolygonDef();
         boxDef.SetAsBox(50, 0.5);
         boxDef.friction = 1;
         boxDef.density = 0; 
 
         body = world.CreateBody(bodyDef);
         body.CreateShape(boxDef);
 
         boxDef.SetAsOrientedBox(1, 2, new b2Vec2(-50, 0.5), 0);
         body.CreateShape(boxDef);
 
         boxDef.SetAsOrientedBox(1, 2, new b2Vec2(50, 0.5), 0);
         body.CreateShape(boxDef);
 
         boxDef.SetAsOrientedBox(3, 0.5, new b2Vec2(5, 1.5), Math.PI/4);
         body.CreateShape(boxDef);
 
         boxDef.SetAsOrientedBox(3, 0.5, new b2Vec2(3.5, 1), Math.PI/8);
         body.CreateShape(boxDef);
 
         boxDef.SetAsOrientedBox(3, 0.5, new b2Vec2(9, 1.5), -Math.PI/4);
         body.CreateShape(boxDef);
 
         boxDef.SetAsOrientedBox(3, 0.5, new b2Vec2(10.5, 1), -Math.PI/8);
         body.CreateShape(boxDef);
 
         body.SetMassFromShapes();
 
 
         // add random shit //
         circleDef = new b2CircleDef();
         circleDef.density = 0.01;
         circleDef.friction = 0.1;
         circleDef.restitution = 0.5;
 
         for (i = 0; i < 30; i++) {
            circleDef.radius = Math.random()/20+0.02;
 
            bodyDef = new b2BodyDef();
            bodyDef.position.Set(Math.random()*35+15, 1);
            bodyDef.allowSleep = true;
            bodyDef.linearDamping = 0.1;
            bodyDef.angularDamping = 0.1;
 
            body = world.CreateBody(bodyDef);
 
            body.CreateShape(circleDef);
            body.SetMassFromShapes();
         }
 
 
         // add cart //
         bodyDef = new b2BodyDef();
         bodyDef.position.Set(0, 3.5);
 
         cart = world.CreateBody(bodyDef);
 
         boxDef = new b2PolygonDef();
         boxDef.density = 2;
         boxDef.friction = 0.5;
         boxDef.restitution = 0.2;
         boxDef.filter.groupIndex = -1;
 
         boxDef.SetAsBox(1.5, 0.3);
         cart.CreateShape(boxDef);
 
         boxDef.SetAsOrientedBox(0.4, 0.15, new b2Vec2(-1, -0.3), Math.PI/3);
         cart.CreateShape(boxDef);
 
         boxDef.SetAsOrientedBox(0.4, 0.15, new b2Vec2(1, -0.3), -Math.PI/3);
         cart.CreateShape(boxDef);
 
         cart.SetMassFromShapes();
 
         boxDef.density = 1;
 
 
         // add the axles //
         axle1 = world.CreateBody(bodyDef);
 
         boxDef.SetAsOrientedBox(0.4, 0.1, new b2Vec2(-1 - 0.6*Math.cos(Math.PI/3), -0.3 - 0.6*Math.sin(Math.PI/3)), Math.PI/3);
         axle1.CreateShape(boxDef);
         axle1.SetMassFromShapes();
 
         prismaticJointDef = new b2PrismaticJointDef();
         prismaticJointDef.Initialize(cart, axle1, axle1.GetWorldCenter(), new b2Vec2(Math.cos(Math.PI/3), Math.sin(Math.PI/3)));
         prismaticJointDef.lowerTranslation = -0.3;
         prismaticJointDef.upperTranslation = 0.5;
         prismaticJointDef.enableLimit = true;
         prismaticJointDef.enableMotor = true;
 
         spring1 = world.CreateJoint(prismaticJointDef) as b2PrismaticJoint;
 
 
         axle2 = world.CreateBody(bodyDef);
 
         boxDef.SetAsOrientedBox(0.4, 0.1, new b2Vec2(1 + 0.6*Math.cos(-Math.PI/3), -0.3 + 0.6*Math.sin(-Math.PI/3)), -Math.PI/3);
         axle2.CreateShape(boxDef);
         axle2.SetMassFromShapes();
 
         prismaticJointDef.Initialize(cart, axle2, axle2.GetWorldCenter(), new b2Vec2(-Math.cos(Math.PI/3), Math.sin(Math.PI/3)));
 
         spring2 = world.CreateJoint(prismaticJointDef) as b2PrismaticJoint;
 
 
         // add wheels //
         circleDef.radius = 0.7;
         circleDef.density = 0.1;
         circleDef.friction = 5;
         circleDef.restitution = 0.2;
         circleDef.filter.groupIndex = -1;
 
         for (i = 0; i < 2; i++) {
 
            bodyDef = new b2BodyDef();
            if (i == 0) bodyDef.position.Set(axle1.GetWorldCenter().x - 0.3*Math.cos(Math.PI/3), axle1.GetWorldCenter().y - 0.3*Math.sin(Math.PI/3));
            else bodyDef.position.Set(axle2.GetWorldCenter().x + 0.3*Math.cos(-Math.PI/3), axle2.GetWorldCenter().y + 0.3*Math.sin(-Math.PI/3));
            bodyDef.allowSleep = false;
 
            if (i == 0) wheel1 = world.CreateBody(bodyDef);
            else wheel2 = world.CreateBody(bodyDef);
 
            (i == 0 ? wheel1 : wheel2).CreateShape(circleDef);
            (i == 0 ? wheel1 : wheel2).SetMassFromShapes();
 
         }
 
 
         // add joints //
         revoluteJointDef = new b2RevoluteJointDef();
         revoluteJointDef.enableMotor = true;
 
         revoluteJointDef.Initialize(axle1, wheel1, wheel1.GetWorldCenter());
         motor1 = world.CreateJoint(revoluteJointDef) as b2RevoluteJoint;
 
         revoluteJointDef.Initialize(axle2, wheel2, wheel2.GetWorldCenter());
         motor2 = world.CreateJoint(revoluteJointDef) as b2RevoluteJoint;
 
      }
 
 
      public function update(e : Event) : void {
 
         if (input.isPressed(32)) {
            world = null;
            init();
            return;
         }
 
         motor1.SetMotorSpeed(15*Math.PI * (input.isPressed(40) ? 1 : input.isPressed(38) ? -1 : 0));
         motor1.SetMaxMotorTorque(input.isPressed(40) || input.isPressed(38) ? 17 : 0.5);
 
         motor2.SetMotorSpeed(15*Math.PI * (input.isPressed(40) ? 1 : input.isPressed(38) ? -1 : 0));
         motor2.SetMaxMotorTorque(input.isPressed(40) || input.isPressed(38) ? 12 : 0.5);
 
         spring1.SetMaxMotorForce(30+Math.abs(800*Math.pow(spring1.GetJointTranslation(), 2)));
         //spring1.SetMotorSpeed(-4*Math.pow(spring1.GetJointTranslation(), 1));
         spring1.SetMotorSpeed((spring1.GetMotorSpeed() - 10*spring1.GetJointTranslation())*0.4);         
 
         spring2.SetMaxMotorForce(20+Math.abs(800*Math.pow(spring2.GetJointTranslation(), 2)));
         spring2.SetMotorSpeed(-4*Math.pow(spring2.GetJointTranslation(), 1));
 
         cart.ApplyTorque(30*(input.isPressed(37) ? 1: input.isPressed(39) ? -1 : 0));
 
         screen.x -= (screen.x - (-DRAW_SCALE*cart.GetWorldCenter().x + SCREEN_WIDTH/2 - cart.GetLinearVelocity().x*10))/3;
         screen.y -= (screen.y - (DRAW_SCALE*cart.GetWorldCenter().y + 2*SCREEN_HEIGHT/3 + cart.GetLinearVelocity().y*6))/3;
 
         world.Step(TIME_STEP, ITERATIONS);
 
         FRateLimiter.limitFrame(60);
 
      }
 
   }
 
}

Follow the official thread here.

April 6, 2009 | Filed Under Box2D, Flash, Game design | 11 Comments 

The engine behind Splitter Flash game : working code

I think we finally have a working slicing engine. It started with The engine behind Splitter Flash game, then come The engine behind Splitter Flash game – first AS3 prototype and The engine behind Splitter Flash game – new AS3 prototypes.

Now Guillaume Pommey aka pompom sent us a working version.

I revised my prototype of slicing engine two days ago and I corrected a lot of errors. After an afternoon on my code, I resolved almost all my problems.

I am proud ^^, now the slicing engine works.

I joint the Main.as and the .fla cause I use radio button to change the cutter style, I let you discover it :) .

Ps : Don’t forget that I use the Raycast function so speak about this on your blog.

For more information about Raycast function check Box2D Raycasts post.

The engine works perfectly, and has two ways of cutting objects: the laser mode cuts objects when you press C while the cutter one lets you cut by drawing a line. Read more

March 9, 2009 | Filed Under Actionscript 3, Box2D, Flash, Users contributions | 8 Comments 

Full Totem Destroyer prototype

Some time ago I posted Create a Flash game like Totem Destroyer, and now I am showing you a complete prototype made by Collin Douch.

The prototype features slimy and non-removable blocks and collision detection between the totem and the ground.

Such detection was made customizing Box2D’s b2ContactListener class. For more information about this class refer to Understanding how Box2D manages collisions. Read more

March 6, 2009 | Filed Under Actionscript 3, Box2D, Flash, Game design, Users contributions | 6 Comments 

Erase Box: the tutorial

Some days ago I blogged about Erase Box, a Box2D game made with my tutorials, now it’s time to publish Rodrigo’s tutorial.

« On a game I was making, I needed a way to detect if a body was leaving the screen.

That can be done by checking the x and y positions of it, but I also wanted to explore Box2D features.

That was actually good, because I found another way to do that, and it can be of great help on other projects.

Sensors are bodies that won’t directly interact with others.

They won’t make a moving box stop when they hit, i.e.

That being said, they are still useful.

Box2D will keep track of it’s “contacts” just as if it were a normal body, so they can be used as exactly what their name means, a sensor.

Also, Box2D allows you to “attach” some information to a body, so that it can be distinguished from others.

Let’s see an example: Read more

February 25, 2009 | Filed Under Actionscript 3, Box2D, Flash, Users contributions | 6 Comments 

Basic Filler engine with Box2D – part 1

Do you remember Filler?

Filler

In Filler, your goal is simple: fill 2/3 of the level. To create a filler ball, press down. It will grow until you release the mouse button, it hits another filler ball, or a bouncing ball runs into it.

I am showing you the first part, the creation of the filler ball by pressing down the mouse, with no collision detection while you are creating the ball.

The code is mainly taken from Drawing circles on the fly in Box2D – fleshMaker version, but uses movieclips for the balls (so I removed the debug draw) and has a different way of creating circles on the fly.

This is the script: Read more

February 23, 2009 | Filed Under Actionscript 3, Box2D, Flash, Game design | 8 Comments 

Erase Box, a Box2D game made with my tutorials

I am going to show you a cute game Rodrigo made following my tutorials

« I created a Box2D flash game using some tutorials available on your website.
It’s not very cool, but being my very first AS3 and Box2D game, I think that I did a good job.

Erase Box

Erase Box

It’s a mix of your tutorials about “Box2D for absolute begginers” and “Totem Destroyer Prototype“.
I also added some other features, such as the one to detect bodies falling off the screen (which was a pain because I couldn’t find anything close to that). I can make a quick tutorial on how to do that if you want.

Thanks and hope you like it :) »

That’s it… while we are waiting for the tutorial, in my opinion a quick way to detect if a body is falling off the screen is checking if its x and y positions are inside the stage… anyway… let’s wait for the tut.

February 21, 2009 | Filed Under Actionscript 3, Box2D, Flash, Game design, Users contributions | 12 Comments 

The engine behind Splitter Flash game – new AS3 prototypes

Splitting Box2D objects seem to be the ultimate challenge around here… after The engine behind Splitter Flash game – first AS3 prototype, now we have two updates… the first by Guillaume Pommey, author of the previous prototype and the second one by Bryce Summer.

While Guillaume wants to refine a bit the final code before publishing it, here it is Bryce work:

Here is my messy attempt at recreating the splitter engine that you posted about on your blog. The code is VERY messy and it doesn’t really work but I decided to send it to you incase it would help at all. The controls are a little funky, you have to move the mouse over to the lower right corner so that the red line is across one of the shapes and click. Sometimes it will (sort of)split it, sometimes it will do nothing. Gravity is disabled at first, hold g to turn it on and release it to turn it off(I added the gravity toggle to try and figure out what was going wrong).

The actionscript resides in two files, one in the timeline and one in the Cutter class

This is the one in the timeline: Read more

February 19, 2009 | Filed Under Actionscript 3, Box2D, Flash, Users contributions | 2 Comments 

Next Page →

Posts