Blitting begins!

package
{
	import flash.display.Sprite;
	import flash.events.Event;
	import flash.display.Bitmap;
	import flash.display.BitmapData;
	import flash.geom.Point;
	import flash.geom.Rectangle;

	public class Main extends Sprite
	{
		[Embed(source = "../Images/Background.png")]
		private var background:Class;

		[Embed(source = "../Images/uiToolbar.png")]
		private var UI:Class;

		[Embed(source="../Images/Test.png")]
		private var test:Class;

		private var pointBG: Point;
		private var pointUI: Point;
		private var rectBG: Rectangle;
		private var rectUI: Rectangle;
		private var rectUnit: Rectangle;

		private var _screen:BitmapData;
		private var bg:BitmapData;
		private var ui:BitmapData;
		private var spriteData: BitmapData;

		private var stats:Stats;
		private var sprites:Vector.<SpriteClass>;
		private var sprite:SpriteClass;

		private var i:int;
		private var count:int = 40; //160
		private var xNum:Number;
		private var yNum:Number;
		private var frameCount:int;

		public function Main():void
        {
			bg = (new background()).bitmapData;
			rectBG = bg.rect;
			pointBG = bg.rect.topLeft;
			ui = (new UI()).bitmapData;
			rectUI = ui.rect;
			pointUI = ui.rect.topLeft;
			pointUI.y = 390;

			_screen = new BitmapData(stage.stageWidth, stage.stageHeight, false, 0xCCCCCC); // building my only displayobject
			addChild(new Bitmap(_screen)); // adding it to the stage and keeping a ref to datas

			stats = new Stats();
			addChild(stats);

			spriteData = (new test()).bitmapData;
			rectUnit = spriteData.rect;

			sprites = new Vector.<SpriteClass>();
			for (i = 0; i < count; i++)
			{
				sprite = new SpriteClass();
				sprite.destX = 300 + 20*(i%4);
				sprite.destY = 250; // + 10*(int(Math.random()*4));
				sprite.x = int(Math.random() * 700);
				sprite.y = int(Math.random() * 500);
				sprite.position = new Point(sprite.x, sprite.y);
				sprites.push(sprite);
			}

			frameCount = 0;
			addEventListener(Event.ENTER_FRAME, MainEngine);
        }

		private function MainEngine(e:Event):void
		{
			_screen.copyPixels(bg, rectBG, pointBG);
			_screen.copyPixels(ui, rectUI, pointUI);
			_screen.lock();
			for (i = 0; i < count; i++)
			{
				sprites[i].Update();
				_screen.copyPixels(spriteData, rectUnit, sprites[i].position);
			}
			_screen.unlock();
			frameCount++;
		}

	}

}

import flash.geom.Point;

class SpriteClass
{
	public var x:Number;
	public var y:Number;
	public var destX:Number;
	public var destY:Number;
	public var speed:Number;
	public var remainingMoveRate:Number;

	public var position: Point;

	private var a:Number;
	private var b:Number;
	private var xDelta:Number;
	private var yDelta:Number;
	private var maxMoveSquared:Number;
	private var unitAlpha:Number;

	public function SpriteClass()
	{
		speed = 5.5;
		remainingMoveRate = speed;
	}

	public function Update():void
	{
		MoveUnit();
		position.x = x;
		position.y = y;
	}

	public function scalingUnit():void{
		//bitmapCanvas.scaleX = 0.75+((y-190)/400);
		//bitmapCanvas.scaleY = 0.75+((y-190)/400);
	}

	public function MoveUnit():Boolean
	{
		a = Math.abs(destX - x);
		b = Math.abs(destY - y);

		if (remainingMoveRate > 1e-4) {
			// Check if the unit can reach the dest coordinates immediately.
			maxMoveSquared = a * a + b * b;
			if (maxMoveSquared <= remainingMoveRate * remainingMoveRate) {
				x = destX;
				y = destY;
				//scalingUnit();
				remainingMoveRate -= Math.sqrt(maxMoveSquared);
				return true;  // Indicate that the unit has reached its dest.
			}

			// Determine the point where the unit will wind up in on its way
			// to (destX, destY).
			unitAlpha = Math.atan(b / a);
			xDelta = Math.cos(unitAlpha) * speed;
			yDelta = Math.sin(unitAlpha) * speed;
			destX > x ? x += xDelta : x -= xDelta;
			if(b > 1e-4){
				destY > y ? y += yDelta : y -= yDelta;
				//scalingUnit();
			}
		}

		// Restore the remaining move rate for the next frame.
		remainingMoveRate = speed;

		// Indicate that the unit has not arrived at its dest yet.
		return false;
	}  // public function move
}