Necklace Simulation

chasemgray — Sun, 07 Sep 2008 19:51:28 +0000

I had some ideas that required some sort of necklace simulator through a web interface. I didn’t have much experience programming anything complex in ActionScript, but I was sure that would be the way to go. I have seen some amazing work done with Flash applications over the past few years and I had no doubt that Flash could handle such an application. So I set out on one weekend to put together a quick prototype for my idea.

Of course the first question I had was what physics libraries are available for Flash these days. I had some experience in the past using Newton and various wrappers in C++ for a game project. My experience with Newton would end up helping me pick up a new physics engine relatively easy.

There were a couple of choices to choose from and I started my search by reading some reviews found on GeekGlue. From this I was able to reduce my search to the Actionscript Physics Engine (APE) and Box2DFlashAS3. APE seemed much easier to get started with, but I wasn’t sure if it would accomplish what I wanted without a lot of massaging. After further reading on some forums, I found that the rope simulation in APE is much more limited because there is only one type of joint available at this time. Box2D has 6 different types of joints and their provided rope bridge looked a little better. The fact that Box2D had ragdoll physics examples made me feel that I would have as much control as I needed to create the necklace simulation I wanted.

After choosing Box2D I wanted to take their rope “springy” bridge demo and see if that could be easily turned into some sort of free falling rope. This was not as simple as adding links and changing a few variables like I had hoped. If you simply add links to the rope, after adding too many the iterative solver breaks the joints with the default configuration. I had to search for a while to figure out why this was. After some searching, I found that a joint can only handle about a 10:1 weight ratio before giving out. The solution to this is the increase the number of iterations of decrease the step time. This of course will slow down your simulation depending on how much you have to increase the number of iterations. I had to change mine from about 10 to 40. My simulation was still running at a decent speed but in the future I am not sure how this will hold up with more physics bodies flying around. This was a huge problem for a while for me and I was very glad to finally find a solution. If you have joints that are breaking due to too much force being applied to them is too much without adding more iterations to the engine so it can accurately solve the joint forces. I hope someone with a similar problem can find this post because it took me a while to find a solution on a forum somewhere.

I am not concerned with creating a nice looking application at this time since this was just a weekend project I was doing on the side. The goals for the prototype of my necklace simulator I wanted to have the following:

A rope like necklace that could be moved around by the user with realistic physics.
Two end pieces on the necklace that were different than the rest of the necklace and could be connected to things.
Two or more connectors in the world that could have a necklace endpiece connected to them and unattached when the user wants to move the necklace again.
A prototype of a bead which can be moved by the user and placed on the necklace.
A background of a neck or something so that it is easy to see what the necklace would look like on a person.

For my resulting application, I simply modified the default Test class provided with Box2DFlashAS3 to have instances of the objects in the world such as the rope and beads. Previously it was a base class for various tests. This might not be the best solution, but it was fine for my prototype to see if things would work. I’ll include the entire source here and highlight my changes as well.

Playground.as

/*
* Copyright (c) 2006-2007 Erin Catto http://www.gphysics.com
*
* This software is provided 'as-is', without any express or implied
* warranty.  In no event will the authors be held liable for any damages
* arising from the use of this software.
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*/
 
package TestBed{
 
	import Box2D.Dynamics.*;
	import Box2D.Collision.*;
	import Box2D.Collision.Shapes.*;
	import Box2D.Dynamics.Joints.*;
	import Box2D.Dynamics.Contacts.*;
	import Box2D.Common.*;
	import Box2D.Common.Math.*;
	import Main;
	import General.Input;
 
	import flash.utils.getTimer
	import flash.display.*;
 
	public class Playground{
 
		public function Playground(){
 
			m_sprite = Main.m_sprite;
 
			var worldAABB:b2AABB = new b2AABB();
			worldAABB.lowerBound.Set(-1000.0, -1000.0);
			worldAABB.upperBound.Set(1000.0, 1000.0);
 
			// Define the gravity vector
			var gravity:b2Vec2 = new b2Vec2(0.0, 10.0);
 
			// Allow bodies to sleep
			var doSleep:Boolean = true;
 
			// Construct a world object
			m_world = new b2World(worldAABB, gravity, doSleep);
			// set debug draw
			var dbgDraw:b2DebugDraw = new b2DebugDraw();
			//var dbgSprite:Sprite = new Sprite();
			//m_sprite.addChild(dbgSprite);
			dbgDraw.m_sprite = m_sprite;
			dbgDraw.m_drawScale = 30.0;
			dbgDraw.m_fillAlpha = 0.3;
			dbgDraw.m_lineThickness = 1.0;
			dbgDraw.m_drawFlags = b2DebugDraw.e_shapeBit | b2DebugDraw.e_jointBit;
			m_world.SetDebugDraw(dbgDraw);
 
			// Create border of boxes
			var wallSd:b2PolygonDef = new b2PolygonDef();
			var wallBd:b2BodyDef = new b2BodyDef();
			var wallB:b2Body;
 
			// Left
			wallBd.position.Set(-95 / m_physScale, 360/m_physScale/2);
			wallSd.SetAsBox(100/m_physScale, 400/m_physScale/2);
			wallB = m_world.CreateBody(wallBd);
			wallB.CreateShape(wallSd);
			wallB.SetMassFromShapes();
			// Right
			wallBd.position.Set((640+95) / m_physScale, 360/m_physScale/2);
			wallB = m_world.CreateBody(wallBd);
			wallB.CreateShape(wallSd);
			wallB.SetMassFromShapes();
			// Top
			wallBd.position.Set(640/m_physScale/2, -95/m_physScale);
			wallSd.SetAsBox(680/m_physScale/2, 100/m_physScale);
			//wallB = m_world.CreateBody(wallBd);
			//wallB.CreateShape(wallSd);
			//wallB.SetMassFromShapes();
			// Bottom
			wallBd.position.Set(640/m_physScale/2, (360+95)/m_physScale);
			wallB = m_world.CreateBody(wallBd);
			wallB.CreateShape(wallSd);
			wallB.SetMassFromShapes();
 
			m_rope = new Rope(m_world, m_physScale);
 
			m_leftHookJoint = null;
			m_rightHookJoint = null;
 
			m_leftHook = new Hook(m_world, m_physScale, new b2Vec2(175/m_physScale, 50/m_physScale), 10/m_physScale);
			m_rightHook = new Hook(m_world, m_physScale, new b2Vec2(500/m_physScale, 50/m_physScale), 10/m_physScale);
			m_hookJointDef = new b2RevoluteJointDef();
 
			m_bead = new Bead(m_world, m_physScale, 7.5/m_physScale);
 
		}
 
		public function Update():void{
 
			// Update mouse joint
			UpdateMouseWorld()
			MouseDestroy();
			MouseDrag();
 
			// Update physics
			var physStart:uint = getTimer();
			m_world.Step(m_timeStep, m_iterations);
			Main.m_fpsCounter.updatePhys(physStart);
 
		}
 
		//======================
		// Member Data
		//======================
		public var m_world:b2World;
 
		public var m_mouseJoint:b2MouseJoint;
		public var m_iterations:int = 40;
		public var m_timeStep:Number = 1/30;
		public var m_physScale:Number = 30;
		// world mouse position
		static public var mouseXWorldPhys:Number;
		static public var mouseYWorldPhys:Number;
		static public var mouseXWorld:Number;
		static public var mouseYWorld:Number;
		// Sprite to draw in to
		public var m_sprite:Sprite;
		public var m_rope:Rope;
		public var m_hookJointDef:b2RevoluteJointDef;
		public var m_leftHookJoint:b2Joint;
		public var m_rightHookJoint:b2Joint;
		public var m_leftHook:Hook;
		public var m_rightHook:Hook;
		public var m_bead:Bead;
 
		//======================
		// Update mouseWorld
		//======================
		public function UpdateMouseWorld():void{
			mouseXWorldPhys = (Input.mouseX)/m_physScale;
			mouseYWorldPhys = (Input.mouseY)/m_physScale; 
 
			mouseXWorld = (Input.mouseX);
			mouseYWorld = (Input.mouseY);
		}
 
		//======================
		// Mouse Drag
		//======================
		public function MouseDrag():void{
			// mouse press
			if (Input.mouseDown &amp;&amp; !m_mouseJoint){
 
				var body:b2Body = GetBodyAtMouse();
 
				if (body)
				{
					var md:b2MouseJointDef = new b2MouseJointDef();
					md.body1 = m_world.GetGroundBody();
					md.body2 = body;
					md.target.Set(mouseXWorldPhys, mouseYWorldPhys);
					md.maxForce = 600.0 * body.GetMass();
					md.timeStep = m_timeStep;
					m_mouseJoint = m_world.CreateJoint(md) as b2MouseJoint;
					body.WakeUp();
					if (body == m_rope.m_leftHook || body == m_rope.m_rightHook){
						if (m_leftHookJoint &amp;&amp; body == m_leftHookJoint.GetBody2())
						{
								m_world.DestroyJoint(m_leftHookJoint);
								m_leftHookJoint = null;
						}
						if (m_rightHookJoint &amp;&amp; body == m_rightHookJoint.GetBody2())
						{
								m_world.DestroyJoint(m_rightHookJoint);
								m_rightHookJoint = null;
						}
					}
					if (body == m_bead.m_body)
					{
						m_bead.SetCollidable(false);
					}
				}
			}
 
			// mouse release
			if (!Input.mouseDown){
				if (m_mouseJoint)
				{
					//get body being clicked on
					var clickedBody:b2Body = m_mouseJoint.GetBody2();
					m_world.DestroyJoint(m_mouseJoint);
					m_mouseJoint = null;
					if (clickedBody == m_bead.m_body)
					{
						m_bead.SetCollidable(true);
					}
					if (m_rope.IsAttachable( clickedBody))
					{
 
						var ground:b2Body = m_world.GetGroundBody();
						if (m_leftHook.IsTouching(clickedBody))
						{
							trace("test");
							m_hookJointDef.Initialize(m_leftHook.m_body,  clickedBody, new b2Vec2(mouseXWorldPhys, mouseYWorldPhys));
							if (m_leftHookJoint){
								m_world.DestroyJoint(m_leftHookJoint);
								m_leftHookJoint = null;
							}
							m_leftHookJoint = m_world.CreateJoint(m_hookJointDef);
						}
						else if (m_rightHook.IsTouching( clickedBody))
						{
							if (m_rightHookJoint){
								m_world.DestroyJoint(m_rightHookJoint);
								m_rightHookJoint = null;
							}
							m_hookJointDef.Initialize(m_rightHook.m_body,  clickedBody,  new b2Vec2(mouseXWorldPhys, mouseYWorldPhys));
							m_rightHookJoint = m_world.CreateJoint(m_hookJointDef);
						}
					}
				}
			}
 
			// mouse move
			if (m_mouseJoint)
			{
				var p2:b2Vec2 = new b2Vec2(mouseXWorldPhys, mouseYWorldPhys);
				m_mouseJoint.SetTarget(p2);
			}
		}
 
		//======================
		// Mouse Destroy
		//======================
		public function MouseDestroy():void{
			// mouse press
			if (!Input.mouseDown &amp;&amp; Input.isKeyPressed(68/*D*/)){
 
				var body:b2Body = GetBodyAtMouse(true);
 
				if (body)
				{
					m_world.DestroyBody(body);
					return;
				}
			}
		}
 
		//======================
		// GetBodyAtMouse
		//======================
		private var mousePVec:b2Vec2 = new b2Vec2();
		public function GetBodyAtMouse(includeStatic:Boolean=false):b2Body{
			// Make a small box.
			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);
 
			// Query the world for overlapping shapes.
			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 &lt; 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;
		}
 
	}
 
}

The first change is at the end of the constructor where I create the items that are in the world.

m_rope = new Rope(m_world, m_physScale);
 
m_leftHookJoint = null;
m_rightHookJoint = null;
 
m_leftHook = new Hook(m_world, m_physScale, new b2Vec2(175/m_physScale, 50/m_physScale), 10/m_physScale);
m_rightHook = new Hook(m_world, m_physScale, new b2Vec2(500/m_physScale, 50/m_physScale), 10/m_physScale);
m_hookJointDef = new b2RevoluteJointDef();
 
m_bead = new Bead(m_world, m_physScale, 7.5/m_physScale);

The second noticable difference is the addition of the member variables.

public var m_rope:Rope;
public var m_hookJointDef:b2RevoluteJointDef;
public var m_leftHookJoint:b2Joint;
public var m_rightHookJoint:b2Joint;
public var m_leftHook:Hook;
public var m_rightHook:Hook;
public var m_bead:Bead;

In the mouse drag function are the most important additions. In the first part of this function we are focusing on mouse presses, or an initiated drag. The first thing we do is check to see if we clicked on a joint at one of our hooking points, if so we want to destroy that joint and let the mouse move the necklace wherever it wants to. We also want the user to be able to click a bead and place it on the necklace without colliding with the necklace while trying to drag the bead, this is also check for here, we turn off collisions for a bead if it is being dragged.

\The second part of the mouse drag function is when the mouse button is relased after dragging has occurred. When this happens, we check to see if we were holding a bead, if we were we set it to be collidable, so that it will stay on the necklace if it was placed there. We are also checking to see if the right or left hook are clicked on with one of the end pieces of the necklace. If they are then we create a new joint between the hook and the necklace endpiece.

//======================
//======================
// Mouse Drag
//======================
public function MouseDrag():void{
	// mouse press
	if (Input.mouseDown &amp;&amp; !m_mouseJoint){
 
		var body:b2Body = GetBodyAtMouse();
 
		if (body)
		{
			var md:b2MouseJointDef = new b2MouseJointDef();
			md.body1 = m_world.GetGroundBody();
			md.body2 = body;
			md.target.Set(mouseXWorldPhys, mouseYWorldPhys);
			md.maxForce = 600.0 * body.GetMass();
			md.timeStep = m_timeStep;
			m_mouseJoint = m_world.CreateJoint(md) as b2MouseJoint;
			body.WakeUp();
			if (body == m_rope.m_leftHook || body == m_rope.m_rightHook){
				if (m_leftHookJoint &amp;&amp; body == m_leftHookJoint.GetBody2())
				{
						m_world.DestroyJoint(m_leftHookJoint);
						m_leftHookJoint = null;
				}
				if (m_rightHookJoint &amp;&amp; body == m_rightHookJoint.GetBody2())
				{
						m_world.DestroyJoint(m_rightHookJoint);
						m_rightHookJoint = null;
				}
			}
			if (body == m_bead.m_body)
			{
				m_bead.SetCollidable(false);
			}
		}
	}
 
	// mouse release
	if (!Input.mouseDown){
		if (m_mouseJoint)
		{
			//get body being clicked on
			var clickedBody:b2Body = m_mouseJoint.GetBody2();
			m_world.DestroyJoint(m_mouseJoint);
			m_mouseJoint = null;
			if (clickedBody == m_bead.m_body)
			{
				m_bead.SetCollidable(true);
			}
			if (m_rope.IsAttachable( clickedBody))
			{
 
				var ground:b2Body = m_world.GetGroundBody();
				if (m_leftHook.IsTouching(clickedBody))
				{
					trace("test");
					m_hookJointDef.Initialize(m_leftHook.m_body,  clickedBody, new b2Vec2(mouseXWorldPhys, mouseYWorldPhys));
					if (m_leftHookJoint){
						m_world.DestroyJoint(m_leftHookJoint);
						m_leftHookJoint = null;
					}
					m_leftHookJoint = m_world.CreateJoint(m_hookJointDef);
				}
				else if (m_rightHook.IsTouching( clickedBody))
				{
					if (m_rightHookJoint){
						m_world.DestroyJoint(m_rightHookJoint);
						m_rightHookJoint = null;
					}
					m_hookJointDef.Initialize(m_rightHook.m_body,  clickedBody,  new b2Vec2(mouseXWorldPhys, mouseYWorldPhys));
					m_rightHookJoint = m_world.CreateJoint(m_hookJointDef);
				}
			}
		}
	}
 
	// mouse move
	if (m_mouseJoint)
	{
		var p2:b2Vec2 = new b2Vec2(mouseXWorldPhys, mouseYWorldPhys);
		m_mouseJoint.SetTarget(p2);
	}
}

There are three types that are used in the Playground.as file that we haven’t seen and are not in Box2D. Those are the Rope, Bead, and Hook classes.

The rope is the most complicated and has the most new code. When instantiated it builds itself vertically at a hard coded location. It has an endpiece on each end that is different than the rest of the necklace. Initially I made all pieces of the necklace a rectangle and connected them end to end. This proved to be a mistake because when there was too much bending or twisting between two rectangle shapes at a joint they would sometimes not know how to fix themselves. It would look like a permanent crease between the joint. I was unable to figure out how to fix this problem with rectangles and I figured collisions between spheres is always cheaper so I moved everything to circles.

So the result is that the rope is made up of anywhere between 10 and 60 circles. The values for the number of circles and the size of them is currently hard coded in the rope.as file. Most of what is happening during the building of the rope is pretty obvious. I changed a couple of the collision properties to make things look more realistic.

Each end piece is special and can be attached to a connector in the stage. The isAttachable function checks to see if a given body can be attached to something. I did this so it was easy to change which things could be attached in the future.

One last thing to note is that I made the end pieces collidable with the necklace pieces but the necklace pieces are not collidable with themselves. This saves a lot of computation I’m sure but the main reason was so that you could more easily find an endpiece among a pile of necklace since it should be sitting on top.

Rope.as

import Box2D.Dynamics.*;
import Box2D.Collision.*;
import Box2D.Collision.Shapes.*;
import Box2D.Dynamics.Joints.*;
import Box2D.Dynamics.Contacts.*;
import Box2D.Common.*;
import Box2D.Common.Math.*;
 
public class Rope{
 
	public function Rope(world:b2World, physScale:Number){
 
		// Set block length & width & overlap(to make block connections look smoother)
		m_blockLength =3.5;
		m_blockWidth = 3.5;
		m_overlap = -4.5;
		// Set end piece paramaters
		m_circleRadius = 3;
 
		// Starting height for necklace
		m_startingHeight = -200; 
 
		var vel:b2Vec2 = new b2Vec2();
		vel.Set(5, 0); 
 
		var ground:b2Body = world.GetGroundBody();
		var i:int;
		var anchor:b2Vec2 = new b2Vec2();
		var body:b2Body;
 
		// Bridge
		{
			var sd:b2PolygonDef = new b2PolygonDef();
			sd.SetAsBox(m_blockLength / physScale, m_blockWidth / physScale);
			sd.density = 20;
			sd.friction = .8;
			sd.restitution = 0.0;
			sd.filter.groupIndex = -2;
 
			var cd:b2CircleDef = new b2CircleDef();
			cd.density = 20.0;
			cd.radius = (m_circleRadius) / physScale;
			cd.restitution = 0.0;
			cd.friction=0.8;
			cd.filter.groupIndex = -3;
 
			var bd:b2BodyDef = new b2BodyDef();
			bd.angle = -90 / (180/Math.PI);
			var jd:b2RevoluteJointDef = new b2RevoluteJointDef();
			const numPlanks:int = 50;
 
			jd.lowerAngle = -10 / (180/Math.PI);
			jd.upperAngle = 10 / (180/Math.PI);
			jd.enableLimit = false;
			jd.collideConnected = false;
 
			var prevBody:b2Body = ground;
 
			bd.position.Set(100 / physScale, (m_startingHeight + m_blockLength*2)/physScale)
			//bd.isBullet = true;
			body = world.CreateBody(bd);
			body.CreateShape(sd);
			body.SetMassFromShapes();
			body.SetLinearVelocity(vel);
			m_leftHook = prevBody = body;
			for (i = 0; i &lt; numPlanks; ++i)
			{
				bd.position.Set(100 / physScale, (m_startingHeight + m_blockLength + (m_blockLength*2*i) - m_overlap*i) / physScale);
				bd.isBullet = false;
				bd.linearDamping = 0.1;
				bd.angularDamping = 0.5;
				body = world.CreateBody(bd);
				body.CreateShape(cd);
				body.SetMassFromShapes();
 
				anchor.Set(100 / physScale, (m_startingHeight + (m_blockLength*2*i) - m_overlap*i) / physScale);
 
				jd.Initialize(prevBody, body, anchor);
 
				world.CreateJoint(jd);
 
				prevBody = body;
			}
			bd.linearDamping = 0;
			bd.angularDamping = 0;
			//bd.isBullet = true;
			bd.position.Set(100/physScale, (m_startingHeight + m_blockLength + m_blockLength*2*numPlanks - m_overlap*numPlanks) / physScale);
			body = world.CreateBody(bd);
			body.CreateShape(sd);
			body.SetMassFromShapes();
			m_rightHook = body;
			anchor.Set(100 / physScale, (m_startingHeight + (m_blockLength*2*numPlanks) - m_overlap*numPlanks) / physScale);
			jd.Initialize(prevBody, body, anchor);
			world.CreateJoint(jd);
 
		}
 
	}
 
	public function IsAttachable(body:b2Body) : Boolean {
		if (body == m_leftHook || body == m_rightHook)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
 
	//======================
	// Member Data
	//======================
	public var m_blockLength:Number;
	public var m_blockWidth:Number;
	public var m_circleRadius:Number;
	public var m_overlap:Number;
	public var m_startingHeight:Number;
	public var m_leftHook:b2Body;
	public var m_rightHook:b2Body;
 
}

Creating a bead class that could be placed on the necklace was one thing I was unsure of how to do initially. The end result for my prototype was to create three circle shapes on a single body and to make the center one a sensor. A sensor is something that can collide with other objects but doesn’t cause any actual physical response. It is essentially not collidable but still keeps track of its collisions.

So the constructor creates this complex body. I found very little documentation on how to make a simple complex body out of simple shapes online. It was very easy though and if you look at the bead.as constructor you can see how I did it. The most confusing part was how I was supposed to offset the different shapes in the body. This is accomplished via the Shape class’ localPosition attribute. By modifying this attribute I could offset the shape in the body it will eventually be a part of.

The last thing in this class is the setCollidable function. I needed a way to easily make all of the parts of the bead a sensor temporarily. This was so that the user could drag the bead and not collide with anything and then let go and it would become collidable again.
Bead.as

import Box2D.Dynamics.*;
import Box2D.Collision.*;
import Box2D.Collision.Shapes.*;
import Box2D.Dynamics.Joints.*;
import Box2D.Dynamics.Contacts.*;
import Box2D.Common.*;
import Box2D.Common.Math.*;
 
public class Bead{
 
	public function Bead(world:b2World, physScale:Number, radius:Number){
 
		m_circleRadius = radius;
 
		var cd:b2CircleDef = new b2CircleDef();
		cd.density = 0.01;
		cd.radius = (m_circleRadius);
		cd.friction = 0.1;
		cd.restitution = 0.1;
 
		var bd:b2BodyDef = new b2BodyDef();
 
		cd.localPosition.x = -15 / physScale;
 
		bd.position.Set(400/physScale, 200/physScale)
		bd.isBullet = true;
		m_body = world.CreateBody(bd);
		m_body.CreateShape(cd);
		cd.localPosition.x = 15 / physScale;
		m_body.CreateShape(cd);
		cd.localPosition.x=0;
		cd.isSensor = true;
		m_centerShape = m_body.CreateShape(cd);
		m_body.SetMassFromShapes();
 
	}
 
	public function SetCollidable(toggle:Boolean) : void{
		var currentShape:b2Shape = m_body.GetShapeList();
 
		for(currentShape; currentShape; currentShape = currentShape.m_next){
			if (currentShape == m_centerShape){
				continue;
			}
			currentShape.m_isSensor = !toggle;
		}
	}
 
	//======================
	// Member Data
	//======================
 
	public var m_circleRadius:Number;
	public var m_position:b2Vec2;
	public var m_body:b2Body;
	public var m_centerShape:b2Shape;
 
}

The hook class is very simple and just creates a circle in the location where it is supposed to be. I temporarily just used the physics circle to make it easy to test. I don’t plan to have a physics body be the connector piece in the future unless I am using so sort of callback function. I think it is easy enough to use the isTouching function to check if a body is within touching range of this hook.
Hook.as

import Box2D.Dynamics.*;
import Box2D.Collision.*;
import Box2D.Collision.Shapes.*;
import Box2D.Dynamics.Joints.*;
import Box2D.Dynamics.Contacts.*;
import Box2D.Common.*;
import Box2D.Common.Math.*;
 
public class Hook{
 
	public function Hook(world:b2World, physScale:Number,  position:b2Vec2, radius:Number){
 
		m_circleRadius = radius;
		m_position = position;
 
		var cd:b2CircleDef = new b2CircleDef();
			cd.density = 1.0;
			cd.radius = (m_circleRadius);
			cd.isSensor = true;
			var bd:b2BodyDef = new b2BodyDef();
 
			bd.position.Set(m_position.x, m_position.y)
			m_body = world.CreateBody(bd);
			m_body.CreateShape(cd);
 
	}
 
	public function IsTouching(body:b2Body):Boolean{
		var position = body.GetWorldCenter().Copy();
 
		position.Subtract(m_position);
		position.Abs();
		trace(position.x + " x units away.");
		trace("radius of circle is " + m_circleRadius);
		if (position.x &lt; m_circleRadius &amp;&amp; position.y &lt; m_circleRadius)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	//======================
	// Member Data
	//======================
 
	public var m_circleRadius:Number;
	public var m_position:b2Vec2;
	public var m_body:b2Body;
 
}

The resulting application turned out pretty good. I was not totally satisfied with placing a bead on the necklace, but I ran out of time and had to do real work by that time. I think I could make the bead automatically orient correctly and highlight itself when it is being placed on the right spot on the necklace. Besides that problem I am satisfied with the it as a prototype for a future application I might develop.

Here it is:

Beadr Prototype 1:

Chasing » actionscript

Necklace Simulation