For those who have not followed along this project, you can drag your mouse across the screen to create colidable rectangle particles for the balls and car to bounce off of.

The Main Document class:

package {
	import flash.display.Sprite;
	import flash.display.Shape;
	import flash.ui.Keyboard;
	import flash.events.MouseEvent;
	import flash.events.KeyboardEvent;
	import flash.events.Event;
	import flash.geom.Rectangle;
	import fl.controls.Button;
	import org.cove.ape.*;

	public class Main extends Sprite {

		private var beginX:Number; // top left x position
		private var beginY:Number; // top left y position
       	private var endX:Number; // bottom right x position
       	private var endY:Number; // bottom right y position  

		private var dynRect:RectangleParticle;
		private var circle:CircleParticle;
		private var circleGroup:Group;
        private var defaultGroup:Group;

		private var car:Car;

		public function Main()
		{
			init();
		}

		private function init():void
		{
			stage.frameRate = 55;

            // Initialize the engine. The argument here is the time step value.
            // Higher values scale the forces in the sim, making it appear to run
            // faster or slower. Lower values result in more accurate simulations.
            APEngine.init(1/4);  

            // set up the default diplay container
            APEngine.container = this;  

            APEngine.addMasslessForce(new Vector(0,8));  

            defaultGroup = new Group();  

            defaultGroup.collideInternal = true;

			circleGroup = new Group();
			circleGroup.collideInternal = true;

			// this is the bottom
			var rect:RectangleParticle = new RectangleParticle(345, 680, 710, 40, 0, true);
            defaultGroup.addParticle(rect);  

			var l:RectangleParticle = new RectangleParticle(0, stage.stageHeight / 2 - 20, 10, stage.stageHeight-40, 0, true);
            defaultGroup.addParticle(l);

			var r:RectangleParticle = new RectangleParticle(stage.stageWidth, stage.stageHeight / 2 - 20, 10, stage.stageHeight-40, 0, true);
            defaultGroup.addParticle(r);

            APEngine.addGroup(defaultGroup);
			APEngine.addGroup(circleGroup);

			// make the groups collidable
			defaultGroup.addCollidable(circleGroup);

			addEventListener(Event.ENTER_FRAME, run);

			stage.addEventListener(MouseEvent.MOUSE_DOWN, beginRectDraw);
			stage.addEventListener(MouseEvent.MOUSE_UP, stopRectDraw);

			// build the UI
			buildUI();
		}

		private function beginRectDraw(m:MouseEvent):void
       	{
			beginX = mouseX;
			beginY = mouseY;
       	}

		private function stopRectDraw(m:MouseEvent):void
       	{
			// set the end points
           	endX = mouseX;
		   	endY = mouseY;

			// remove the listeners
			stage.addEventListener(MouseEvent.MOUSE_DOWN, beginRectDraw);
			stage.addEventListener(MouseEvent.MOUSE_UP, stopRectDraw);

			// now draw the rectangle
			drawRectangle();
		}

		private function drawRectangle():void
		{
			if ( beginY < 660 && endY < 660 )
			{
				dynRect = new RectangleParticle(beginX + ( (endX - beginX)/2 ), beginY + ((endY - beginY)/2), endX - beginX, endY - beginY, 0, true);
            	defaultGroup.addParticle(dynRect);
			}
		}

		private function addBall( m:MouseEvent ):void
        {
            circle = new CircleParticle(Math.random() * stage.stageWidth, Math.random() * 100, Math.random() * 25 + 5);
            circleGroup.addParticle(circle);
        }

		private function addCar ( m:MouseEvent ):void
		{
			car = new Car(Math.random() * 0xffffff,Math.random() * 0xffffff);
            APEngine.addGroup(car);
			defaultGroup.addCollidable(car);
			circleGroup.addCollidable(car);

			stage.addEventListener(KeyboardEvent.KEY_DOWN, keyPressed);
			stage.addEventListener(KeyboardEvent.KEY_UP, keyReleased);
		}

		private function run(e:Event):void
        {
            APEngine.step();
            APEngine.paint();
        }

		private function removeLastBall( m:MouseEvent ):void
		{
			if ( circle ) circle.cleanup();
		}

		private function clearBoard( m:MouseEvent ):void
		{
			APEngine.removeGroup(defaultGroup);
			APEngine.removeGroup(circleGroup);
			APEngine.removeGroup(car);
			init();

		}

		function keyPressed(event:KeyboardEvent):void {
            var keySpeed:Number = 0.8;  

            if (event.keyCode == Keyboard.UP || event.keyCode == Keyboard.RIGHT)
            {
                car.speed = keySpeed;
            }  

            if (event.keyCode == Keyboard.DOWN || event.keyCode == Keyboard.LEFT)
            {
                car.speed = -keySpeed;
            }
        }  

        function keyReleased(event:KeyboardEvent):void
        {
            car.speed = 0;
        }  

		private function buildUI():void
		{

			// NEW BUTTONS
            var btnAddBall:Button = new Button();
            btnAddBall.width = 65;
            btnAddBall.height = 25;
            btnAddBall.move ( 5, stage.stageHeight - 20 - btnAddBall.height / 2 );
            btnAddBall.label = "Add Ball";      

            addChild(btnAddBall);      

            btnAddBall.addEventListener(MouseEvent.CLICK, addBall);  

			var btnRemoveBall:Button = new Button();
            btnRemoveBall.width = 120;
            btnRemoveBall.height = 25;
            btnRemoveBall.move ( 75, stage.stageHeight - 20 - btnRemoveBall.height / 2 );
            btnRemoveBall.label = "Remove Last Ball";      

            addChild(btnRemoveBall);

            btnRemoveBall.addEventListener(MouseEvent.CLICK, removeLastBall);

			var btnAddCar:Button = new Button();
            btnAddCar.width = 65;
            btnAddCar.height = 25;
            btnAddCar.move ( 200, stage.stageHeight - 20 - btnAddCar.height / 2 );
            btnAddCar.label = "Add Car";      

            addChild(btnAddCar);

            btnAddCar.addEventListener(MouseEvent.CLICK, addCar);

			var btnClearBoard:Button = new Button();
            btnClearBoard.width = 120;
            btnClearBoard.height = 25;
            btnClearBoard.move ( 575, stage.stageHeight - 20 - btnClearBoard.height / 2 );
            btnClearBoard.label = "Clear Board";      

            addChild(btnClearBoard);

            btnClearBoard.addEventListener(MouseEvent.CLICK, clearBoard);
		}
	}
}

the original Car class file:

package {

	import org.cove.ape.*;

	public class Car extends Group {

		private var wheelParticleA:WheelParticle;
		private var wheelParticleB:WheelParticle;

		public function Car(colorOne:uint=0xffffff, colorTwo:uint=0xffffff) {

			wheelParticleA = new WheelParticle(140,30,14,false,2);
			wheelParticleA.setStyle(0, colorOne, 1, colorTwo);
			addParticle(wheelParticleA);
			wheelParticleA.sprite.cacheAsBitmap = true;

			var suspA:CircleParticle = new CircleParticle(140,0,7,false,10);
			suspA.mass = 0.001;
			suspA.setStyle(1, colorOne, 1, colorOne);
			addParticle(suspA);

			wheelParticleB = new WheelParticle(200,30,14,false,2);
			wheelParticleB.setStyle(0, colorOne, 1, colorTwo);
			addParticle(wheelParticleB);
			wheelParticleB.sprite.cacheAsBitmap = true;

			var suspB:CircleParticle = new CircleParticle(200,0,7,false,10);
			suspB.mass = 0.001;
			suspB.setStyle(1, colorOne, 1, colorOne);
			addParticle(suspB);

			var wheelAConnector:SpringConstraint = new SpringConstraint(wheelParticleA, suspB, .7, false, 8);
			wheelAConnector.setStyle(0, colorOne, 1, colorTwo);
			addConstraint(wheelAConnector);

			var shockAConnector:SpringConstraint = new SpringConstraint(wheelParticleA, suspA, .6, false, 8);
			shockAConnector.setStyle(0, colorOne, 1, colorTwo);
			addConstraint(shockAConnector);

			var wheelBConnector:SpringConstraint = new SpringConstraint(wheelParticleB, suspA, 0.5, false, 8);
			wheelBConnector.setStyle(0, colorOne, 1, colorTwo);
			addConstraint(wheelBConnector);

			var bodyConnector:SpringConstraint = new SpringConstraint(suspA, suspB, 0.2, true, 8);
			bodyConnector.setStyle(0, colorOne, 1, colorTwo);
			addConstraint(bodyConnector);

			var shockBConnector:SpringConstraint = new SpringConstraint(wheelParticleB, suspB, .6, false, 8);
			shockBConnector.setStyle(0, colorOne, 1, colorTwo);
			addConstraint(shockBConnector);

			var axelConnector:SpringConstraint = new SpringConstraint(wheelParticleA, wheelParticleB, .7, false, 8);
			axelConnector.setStyle(0, colorOne, 1, colorTwo);
			addConstraint(axelConnector);
		}

		public function set speed(s:Number):void {
			wheelParticleA.angularVelocity = s;
			wheelParticleB.angularVelocity = s;
		}
	}
}

Here is the document class, naming this file ObjectPlacement.as:

package
{
	import flash.display.Sprite;
	import flash.events.MouseEvent;

	public class ObjectPlacement extends Sprite
	{
		private var cArr:Array; // an array of all my circle objects

		public function ObjectPlacement()
		{
			init();
		}

		private function init():void
		{
			// let's build 4 circles from our Circle class file -> c.as
			// we will pass in a random radius and a random color
			BuildCircles ( 10 );

			// add a Stage Event Listener for Mouse Down
			stage.addEventListener ( MouseEvent.MOUSE_DOWN, changePositions );
		}

		private function BuildCircles ( i:Number ):void
		{
			cArr = new Array();

			for ( var ct:uint = 0; ct < i; ct++ )
			{
				// note: in the line below 'c' represents the class called 'c' - this class is in the file 'c.as'
				cArr.push ( new c ( Math.random() * 20, Math.random() * 0xffffff ) );

				// add this object to the stage
				addChild ( cArr[ct] );

				// move this object to some point on the stage
				cArr[ct].x = Math.random() * stage.stageWidth;
				cArr[ct].y = Math.random() * stage.stageHeight;
			}
		}

		private function changePositions(m:MouseEvent):void
		{
			for ( var d:uint = 0; d < cArr.length; d++ )
			{
				cArr[d].x = Math.random() * stage.stageWidth;
				cArr[d].y = Math.random() * stage.stageHeight;
			}
		}
	}
}

Here is the object class called 'c' and saved as 'c.as':

package {
	/* this class will simply draw a circle */

	import flash.display.Sprite;

	public class c extends Sprite {
		public var radius:Number;
		private var color:uint;

		public function c(radius:Number=20, color:uint=0xb3d830)
		{
			this.radius = radius;
			this.color = color;
			init();
		}

		public function init():void {
			graphics.beginFill(color);
			graphics.drawCircle(0, 0, radius);
			graphics.endFill();
		}
	}
}

package {
    import flash.display.DisplayObject;
    import flash.display.Graphics;
    import flash.display.Shape;
    import flash.display.Sprite;

    public class RoundRectangle extends Sprite {
        private var rrX:Number;
		private var rrY:Number;
		private var rrRadius:Number;
		private var rrWidth:Number;
		private var rrHeight:Number;
        private var bgColor:uint;
        private var borderColor:uint;
        private var borderSize:Number;
		private var child:Shape = new Shape();

        public function RoundRectangle(rrX:Number=0,rrY:Number=0,rrWidth:Number=10,rrHeight:Number=10,rrRadius:Number=0,bgColor:uint=0x000000)
		{
            child = new Shape();
            child.graphics.beginFill(bgColor);
           	child.graphics.lineStyle(borderSize, borderColor);
            child.graphics.drawRoundRect(rrX, rrY, rrWidth, rrHeight, rrRadius);

            child.graphics.endFill();
            addChild(child);
        }
    }
}

package
{
	import flash.display.Sprite;
	import flash.events.MouseEvent;

	public class CurveToExample extends Sprite
	{
		public function CurveToExample()
		{
			stage.addEventListener(MouseEvent.MOUSE_MOVE, drawCurve);
		}

		private function drawCurve(m:MouseEvent):void
		{
			// clear the board on each Mouse Move
			graphics.clear();

			// draw the line
			graphics.lineStyle(1);
			graphics.moveTo(0,stage.stageHeight / 2);
			graphics.curveTo(mouseX,mouseY,stage.stageWidth,stage.stageHeight / 2);
		}
	}
}

package
{
	import flash.display.Sprite;
	import flash.display.Graphics;
	import flash.events.MouseEvent;
	import flash.events.Event;

	public class DrawingTool extends Sprite
	{
		private var drawing:Boolean;

		public function DrawingTool()
		{
			graphics.lineStyle(1,0xffffff);
			graphics.moveTo(mouseX,mouseY);

			stage.addEventListener(MouseEvent.MOUSE_DOWN, MouseDown);
			stage.addEventListener(MouseEvent.MOUSE_UP, MouseUp);

			addEventListener(Event.ENTER_FRAME, Drawing);
		}

		private function MouseDown(m:MouseEvent):void
		{
			graphics.lineStyle(1,Math.random() * 0xffffff);
			drawing = true;
		}

		private function MouseUp(m:MouseEvent):void
		{
			drawing = false;
		}

		private function Drawing(e:Event):void
		{
			if (drawing)
			{
				this.graphics.lineTo(mouseX, mouseY);
			}
			else
			{
				this.graphics.moveTo(mouseX, mouseY);
			}
		}
	}
}

[ a, b, tx
  c, d, ty
  u, v, w ]

Here is the demo of the code below.

Here is the document class:

package
{
	import flash.display.Sprite;
	import flash.display.GradientType;
	import flash.geom.Matrix;

	public class RadialGradient extends Sprite
	{
		private var gType:String;
		private var matrix:Matrix;

		private var bound:Sprite;

		public function RadialGradient()
		{
			var gType:String = GradientType.RADIAL;

			var matrix:Matrix = new Matrix();
			matrix.createGradientBox(550,400,0,0,0);

			var gColors:Array = [0x336699, 0xff9900];
			var gAlphas:Array = [1,1];
			var gRatio:Array = [0,255];

			var bound:Sprite = new Sprite();
			bound.graphics.beginGradientFill(gType,gColors,gAlphas,gRatio,matrix);
			bound.graphics.drawRect(0,0,550,400);
			bound.x = bound.y = 0;

			addChild(bound);
		}
	}
}

Here is the basic Line.as file:

package {
	import flash.display.Sprite;
	import flash.display.Graphics;
	import flash.geom.Rectangle;

	public class Line extends Sprite {
		public var moveToX:Number;
		public var moveToY:Number;
		public var lineToX:Number;
		public var lineToY:Number;

		public function Line(moveToX:Number=0,moveToY:Number=0,lineToX:Number=50,lineToY:Number=0) {
			graphics.lineStyle(1);
			graphics.moveTo(moveToX,moveToY);
			graphics.lineTo(lineToX,lineToY);
		}
	}
}

Here is the document class file Landscape.as

package
{
	import flash.display.Sprite;
	import flash.display.StageAlign;
	import flash.display.StageScaleMode;
	import flash.events.Event;

	public class Landscape extends Sprite
	{
		private var ball:Ball;

		private var line:Line;
		private var lines:Array;
		private var numLines:Number = 8;
		private var moveLineX:Number;
		private var moveLineY:Number;
		private var xIteration:Number = stage.stageWidth / numLines;
		private var beginLineX:Number;
		private var beginLineY:Number;

		public function Landscape()
		{
			init();
		}

		private function init():void
		{
			moveLineX = 0;
			moveLineY = Math.random() * stage.stageHeight;

			beginLineX = xIteration;
			beginLineY = Math.random() * stage.stageHeight;

			for (var i:uint = 0; i < numLines; i++)
			{

				line = new Line(moveLineX,moveLineY,beginLineX,beginLineY);
				addChild(line);

				moveLineX = beginLineX;
				moveLineY = beginLineY;

				beginLineX = (i + 2) * xIteration;
				beginLineY = Math.random() * stage.stageHeight;
			}
		}
	}
}

• graphics.clear
• graphics.moveTo
• graphics.lineStyle
• graphics.beginFill and graphics.endFill
• graphics.lineTo

Full documentation here.

If you hover your mouse over the movie below it will demonstrate the code below:

Here is the Document Class used, with the file named DrawToMouse.as:

package
{
	import flash.events.Event;
	import flash.display.Sprite;

	public class DrawToMouse extends Sprite
	{

		public function DrawToMouse()
		{
			addEventListener(Event.ENTER_FRAME, drawTriangle);
		}

		private function drawTriangle(e:Event):void
		{
			graphics.clear(); // this will clear out any lines drawn previously
			graphics.lineStyle(10, 0, .5); // params: thickness, color, alpha
			graphics.moveTo(stage.stageWidth / 2, stage.stageHeight / 2); // moves the initial draw point
			graphics.beginFill(0x000000); // begin fill with a black color
			graphics.lineTo(mouseX, mouseY); // moves from init point to mouse x and mouse y point
			graphics.lineTo(mouseX, stage.stageHeight / 2); // now draws line to y position of center of stage
			graphics.endFill(); // closes out to make our triangle
		}
	}
}

NOTE: here is a nice plugin for embedding flash movies in your posts for Wordpress/Textpattern publishers:
http://kimili.com/plugins/kml_flashembed

package
{
	import flash.display.Sprite;

	public class DrawRectangle extends Sprite
	{
		private var xPos:Number;
		private var yPos:Number;
		private var rWidth:Number;
		private var rHeight:Number;
		private var color:uint;

		public function DrawRectangle(xPos:Number=0,yPos:Number=0,rWidth:Number=10,rHeight:Number=10,color:uint=0x336699)
		{
			this.graphics.beginFill(color);
			this.graphics.drawRect(xPos,yPos,rWidth,rHeight);
			this.graphics.endFill();
		}
	}
}

package {
	import flash.display.Sprite;

	public class DrawCircle extends Sprite {
		private var radius:Number;
		private var color:uint;

		public function DrawCircle(radius:Number=20, color:uint=0x336699) {
			// center the circle - you can put the x and y positions as
			// parameters of this function.. i just opted not to
			this.x = stage.stageWidth/2;
			this.y = stage.stageHeight/2;

			// draw the circle
			graphics.beginFill(color);
			graphics.drawCircle(0, 0, radius);
			graphics.endFill();
		}

	}
}