Squishing effect:

Here is the standard Ball.as class file:

package {
	import flash.display.Sprite;

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

		public var vx:Number = 0;
		public var vy:Number = 0;

		public function Ball(radius:Number=20, color:uint=0xb3d830) {
			this.radius = radius;
			this.color = color;
			this.diameter = radius * 2;
			init();
		}
		public function init():void {
			graphics.beginFill(color);
			graphics.drawCircle(0, 0, radius);
			graphics.endFill();
		}
	}
}

Here is the document class Throw.as:

package
{
	/* resources: http://ww2.slcc.edu/schools/hum_sci/physics/tutor/2210/kinetic_energy/ */

	import flash.display.Sprite;
	import flash.display.StageAlign;
	import flash.display.StageScaleMode;
	import flash.events.Event;
	import flash.events.MouseEvent;
	import flash.text.TextField;
	import flash.text.TextFieldAutoSize;
	import flash.text.TextFormat; 

	public class Throw extends Sprite
	{
		private var ball:Ball;
		private var vx:Number;
		private var vy:Number;
		private var bounce:Number = -0.7;
		private var gravity:Number = .86;

		private var mass:Number = 10;
		private var springConstant:Number = 1200; // represents 1200 N/m
		private var springDistance:Number;

		private var oldX:Number;
		private var oldY:Number;

		private var ballSpringDistance:TextField;

		public function Throw()
		{
			init();
		}

		private function init():void
		{
			ball = new Ball(30, Math.random() * 0xffffff);
			ball.x = stage.stageWidth / 2;
			ball.y = stage.stageHeight / 2;

			vx = 0;
			vy = 0;
			addChild(ball);

			ball.addEventListener(MouseEvent.MOUSE_DOWN, onMouseDown);
			addEventListener(Event.ENTER_FRAME, onEnterFrame);

			CreateTextField();
			ballSpringDistance.text = "Throw the ball fast or slow against the right wall";
		}

		private function onEnterFrame(event:Event):void
		{
			vy += gravity;
			ball.x += vx;
			ball.y += vy;

			var ltWall:Number = 0;
			var rtWall:Number = stage.stageWidth;
			var topWall:Number = 0;
			var botWall:Number = stage.stageHeight;

			if(ball.x + ball.radius > rtWall)
			{
				springDistance = Math.round((vx * Math.sqrt(mass / 1200)));

				// SQUISH
				ball.width = ball.diameter - springDistance;
				ball.height = ball.diameter + springDistance;

				ball.x = rtWall - ball.radius + (springDistance / 2);

				//trace ("Kinetic Energy: " + (-1 * .5 * mass * vx * vx));
				// distance = velocity times the square root of the mass divided by the spring constant (1200 N/m)
				// trace ("Distance: " + Math.round((vx * Math.sqrt(mass / 1200))));
				ballSpringDistance.y = ball.y - 10;
				ballSpringDistance.x = ball.x - 180;
				ballSpringDistance.text = "Squash: " + Math.round((vx * Math.sqrt(mass / 1200)));

				// stop the ball from traveling:
				removeEventListener(Event.ENTER_FRAME, onEnterFrame);

				init();

			}
			else if(ball.x - ball.radius < ltWall)
			{
				ball.x = ltWall + ball.radius;
				vx *= bounce;
			}
			if(ball.y + ball.radius > botWall)
			{
				ball.y = botWall - ball.radius;
				vy *= bounce;
			}
			else if(ball.y - ball.radius < topWall)
			{
				ball.y = topWall + ball.radius;
				vy *= bounce;
			} else {

			}
		}

		private function onMouseDown(event:MouseEvent):void
		{
			oldX = ball.x;
			oldY = ball.y;
			stage.addEventListener(MouseEvent.MOUSE_UP, onMouseUp);
			ball.startDrag();

			removeEventListener(Event.ENTER_FRAME, onEnterFrame);
			addEventListener(Event.ENTER_FRAME, trackVelocity);
		}

		private function onMouseUp(event:MouseEvent):void
		{
			stage.removeEventListener(MouseEvent.MOUSE_UP, onMouseUp);
			ball.stopDrag();
			removeEventListener(Event.ENTER_FRAME, trackVelocity);
			addEventListener(Event.ENTER_FRAME, onEnterFrame);
		}

		private function trackVelocity(event:Event):void
		{
			vx = ball.x - oldX;
			vy = ball.y - oldY;
			oldX = ball.x;
			oldY = ball.y;
		}

		private function CreateTextField():void
        {
            // pulled this from:
            // http://livedocs.adobe.com/flash/9.0/ActionScriptLangRefV3/flash/text/TextField.html#includeExamplesSummary
            ballSpringDistance = new TextField();
            ballSpringDistance.autoSize = TextFieldAutoSize.LEFT;
            ballSpringDistance.background = false;
            ballSpringDistance.border = false;
			ballSpringDistance.multiline = true;

            var format:TextFormat = new TextFormat();
            format.font = "Arial";
            format.color = 0xffffff;
            format.size = 12;
            format.underline = false;  

			ballSpringDistance.defaultTextFormat = format;
            addChild(ballSpringDistance);
        }
	}
}

package {
	import flash.display.Sprite;
    import flash.display.Loader;
    import flash.display.LoaderInfo;
    import flash.net.URLRequest;
    import flash.events.Event;
    import flash.events.ProgressEvent;	

    public class Wheel extends Sprite {
    	private var myImg:Loader = new Loader();
        public var radius:Number;
        public function Wheel(radius:Number = 100) {
        	this.radius = radius;
            init();
		}

        public function init():void {
			// let's load the image
            try {
            	myImg.load(new URLRequest("wheel.png"));
            }
            catch (error:Error)
            {
            	trace ("Unable to load requested document.");
			}			

            myImg.contentLoaderInfo.addEventListener(Event.COMPLETE,result);
		}

        public function result(evt:Event):void
        {
        	addChild(myImg);
            myImg.width = myImg.height = radius * 2;			

            // change the registration point
            myImg.x = -1 * radius;
            myImg.y = -1 * radius;
		}
	}
}

Here is the document class to control all of this, named WheelToGround.as

package{
	import flash.display.Sprite;
   	import flash.events.Event;
    import flash.events.KeyboardEvent;
    import flash.ui.Keyboard;	

    public class WheelToGround extends Sprite	{
    	private var wheel:Wheel;
        private var vx:Number = 0;
        private var accelerationRate:Number = 0
        private var line:Sprite;		

        public function WheelToGround()
        {
        	init();
		}

		private function init():void
        {
        	// Create the Ground:
            line = new Sprite();
            line.graphics.lineStyle(1);
            line.graphics.moveTo(0, stage.stageHeight - 10);
            line.graphics.lineTo(stage.stageWidth, stage.stageHeight - 10);
            addChild(line);			

            // Get the wheel
            wheel = new Wheel(50);
            addChild(wheel);
            wheel.x = stage.stageWidth / 2;
            wheel.y = stage.stageHeight - 10 - wheel.radius;			

            addEventListener(Event.ENTER_FRAME, onEnterFrame);
            stage.addEventListener(KeyboardEvent.KEY_DOWN, onKeyDown);
            stage.addEventListener(KeyboardEvent.KEY_UP, onKeyUp);
		}		

        private function onKeyDown(event:KeyboardEvent):void
        {
        	if(event.keyCode == Keyboard.LEFT)
            {
            	accelerationRate = -0.2;
			}
            else if(event.keyCode == Keyboard.RIGHT)
            {
            	accelerationRate = 0.2;
			}
		}

        private function onKeyUp(event:KeyboardEvent):void
        {
        	accelerationRate = 0;
		}

        private function onEnterFrame(event:Event):void
        {
        	vx += accelerationRate;
            wheel.x += vx;
            wheel.rotation += vx;			

            // is it off the screen?			

            if ( wheel.x > stage.stageWidth + wheel.width )
            {
            	wheel.x = 0 - wheel.width;
			}
            else if ( wheel.x < 0 - wheel.width )
            {
            	wheel.x = stage.stageWidth + wheel.width;
			}
		}
	}
}

Here is a new updated Ball.as class I got from my book “Foundation Actionscript 3.0 Animation: Making Things Move! by Keith Peters”

package {
	import flash.display.Sprite;

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

		public var vx:Number = 0;
		public var vy:Number = 0;
		public var NewXPos:Number = 0;
		public var NewYPos:Number = 0;

		public function Ball(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();
		}
	}
}

The document class Bouncing.as file to make the balls bounce:

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

	public class Bouncing extends Sprite
	{
		private var balls:Array;
		private var ttl_balls:uint = 10; // total number of balls

		public function Bouncing()
		{
			init();
		}

		private function init():void
		{
			balls = new Array();
			for(var ct:uint = 0; ct < ttl_balls; ct++)
			{
				var ball:Ball = new Ball(Math.random() * 5 + 5, Math.random() * 0xffffff);
				balls.push(ball);

				ball.vx = Math.random() * 10 + (Math.random() * 5);
				ball.vy = Math.random() * 10 + (Math.random() * 5);

				ball.x = Math.random() * stage.stageWidth;
				ball.y = Math.random() * stage.stageHeight;

				addChild(ball);
			}
			addEventListener(Event.ENTER_FRAME, onEnterFrame);
		}

		private function onEnterFrame(event:Event):void
		{
			for(var ct:uint = 0; ct < ttl_balls; ct++)
			{
				var ball:Ball = balls[ct];

				detectAndMove(ball);
			}
		}

		private function detectAndMove(ball:Ball):void
		{
			var myRadius = ball.radius;

			ball.NewXPos=ball.x + ball.vx;
			ball.NewYPos=ball.y + ball.vy;

			// CHECK FOR COLLISIONS TO THE LEFT AND RIGHT BOUNDS
			if (ball.NewXPos + ball.radius > stage.stageWidth)
			{
				ball.vx *= -1;
				ball.NewXPos = stage.stageWidth - ball.radius;
			}
			else if (ball.NewXPos - ball.radius < 0)
			{
				ball.vx *= -1;
				ball.NewXPos = ball.radius;
			}

			// CHECK FOR COLLISIONS TO THE TOP AND BOTTOM BOUNDS
			if (ball.NewYPos + ball.radius > stage.stageHeight)
			{
				ball.vy *= -1;
				ball.NewYPos = stage.stageHeight - ball.radius;
			}
			else if (ball.NewYPos - ball.radius < 0)
			{
				ball.vy *= -1;
				ball.NewYPos = ball.radius;
			}

			// ANIMATE
			ball.x = ball.NewXPos;
			ball.y = ball.NewYPos;
		}
	}
}