Construye un Shoot-'Em-Up en Stage3D: Terreno, IA del enemigo y datos del nivel

// Stage3D Shoot-em-up Tutorial Part 4 

// by Christer Kaitila - www.mcfunkypants.com 

// Entity.as 

// The Entity class will eventually hold all game-specific entity stats 

// for the spaceships, bullets and effects in our game. 

// It stores a reference to a gpu sprite and a few demo properties. 

// This is where you would add hit points, weapons, ability scores, etc. 

// This class handles any AI (artificial intelligence) for enemies as well. 

package 

{ 

	import flash.geom.Point; 

	import flash.geom.Rectangle; 

	public class Entity 

	{ 

		// AI VARIABLES BEGIN 

		// if this is set, custom behaviors are run 

		public var aiFunction : Function; 

		// the AI routines might want access to the entity manager 

		public var gfx:EntityManager; 

		// AI needs to have access to time passing (in seconds) 

		public var age:Number = 0; 

		public var fireTime:Number = 0; 

		public var fireDelayMin:Number = 1; 

		public var fireDelayMax:Number = 6; 

		// an array of points defining a movement path for the AI 

		public var aiPathWaypoints:Array; 

		// how fast we travel from one spline node to the next in seconds 

		public var pathNodeTime:Number = 1; 

		// these offsets are added to the sprite location 

		// so that ships move around but eventually scroll offscreen 

		public var aiPathOffsetX:Number = 0; 

		public var aiPathOffsetY:Number = 0; 

		// how much big the path is (max) 

		public var aiPathSize:Number = 128; 

		// how many different nodes in the path 

		public var aiPathWaypointCount:int = 8; 

		// AI VARIABLES END 

		private var _speedX : Number; 

		private var _speedY : Number; 

		private var _sprite : LiteSprite; 

		public var active : Boolean = true; 

		// collision detection 

		public var isBullet:Boolean = false; // only these check collisions 

		public var leavesTrail:Boolean = false; // creates particles as it moves 

		public var collidemode:uint = 0; // 0=none, 1=sphere, 2=box, etc. 

		public var collideradius:uint = 32; // used for sphere collision		 

		// box collision is not implemented (yet) 

		public var collidebox:Rectangle = new Rectangle(-16, -16, 32, 32); 

		public var collidepoints:uint = 25; // score earned if destroyed 

		public var touching:Entity; // what entity just hit us? 

		public var owner:Entity; // so your own bullets don't hit you 

		public var orbiting:Entity; // entities can orbit (circle) others 

		public var orbitingDistance:Number; // how far in px from the orbit center 

		// used for particle animation (in units per second) 

		public var fadeAnim:Number = 0; 

		public var zoomAnim:Number = 0; 

		public var rotationSpeed:Number = 0; 

		// used to mark whether or not this entity was  

		// freshly created or reused from an inactive one 

		public var recycled:Boolean = false;

		public function Entity(gs:LiteSprite, myManager:EntityManager) 

		{ 

			_sprite = gs; 

			_speedX = 0.0; 

			_speedY = 0.0; 

			// we need a reference to the entity manager 

			gfx = myManager; 

			// we don't want everyone shooting on the first frame 

			fireTime = (gfx.fastRandom() * (fireDelayMax - fireDelayMin)) + fireDelayMin; 

		} 

		public function die() : void 

		{ 

			// allow this entity to be reused by the entitymanager 

			active = false; 

			// skip all drawing and updating 

			sprite.visible = false; 

			// reset some things that might affect future reuses: 

			leavesTrail = false; 

			isBullet = false; 

			touching = null; 

			owner = null; 

			age = 0; 

			collidemode = 0; 

		} 

		public function get speedX() : Number  

		{ 

			return _speedX; 

		} 

		public function set speedX(sx:Number) : void  

		{ 

			_speedX = sx; 

		} 

		public function get speedY() : Number  

		{ 

			return _speedY; 

		} 

		public function set speedY(sy:Number) : void  

		{ 

			_speedY = sy; 

		} 

		public function get sprite():LiteSprite  

		{	 

			return _sprite; 

		} 

		public function set sprite(gs:LiteSprite):void  

		{ 

			_sprite = gs; 

		} 

		// used for collision callback performed in GameActorpool 

		public function colliding(checkme:Entity):Entity 

		{ 

			if (collidemode == 1) // sphere 

			{ 

				if (isCollidingSphere(checkme)) 

					return checkme; 

			} 

			return null; 

		} 

	// simple sphere to sphere collision 

	public function isCollidingSphere(checkme:Entity):Boolean 

	{ 

		// never collide with yourself 

		if (this == checkme) return false; 

		// only check if these shapes are collidable 

		if (!collidemode || !checkme.collidemode) return false; 

		// don't check your own bullets 

		if (checkme.owner == this) return false; 

		// don't check things on the same "team" 

		if (checkme.owner == owner) return false; 

		// don't check if no radius 

		if (collideradius == 0 || checkme.collideradius == 0) return false; 

		// this is the simpler way to do it, but it runs really slow 

		// var dist:Number = Point.distance(sprite.position, checkme.sprite.position); 

		// if (dist <= (collideradius+checkme.collideradius)) 

		// this looks wierd but is 6x faster than the above 

		// see: http://www.emanueleferonato.com/2010/10/13/as3-geom-point-vs-trigonometry/ 

		if (((sprite.position.x - checkme.sprite.position.x) *  

			(sprite.position.x - checkme.sprite.position.x) + 

			(sprite.position.y - checkme.sprite.position.y) * 

			(sprite.position.y - checkme.sprite.position.y)) 

			<=  

			(collideradius+checkme.collideradius)*(collideradius+checkme.collideradius)) 

		{ 

			touching = checkme; // remember who hit us 

			return true; 

		} 

		// default: too far away 

		// trace("No collision. Dist = "+dist); 

		return false; 

	}

	// Calculates 2D cubic Catmull-Rom spline. 

	// See http://www.mvps.org/directx/articles/catmull/  

	public function spline (p0:Point, p1:Point, p2:Point, p3:Point, t:Number):Point  

	{ 

		return new Point ( 

			0.5 * ((2 * p1.x) + 

			t * (( -p0.x + p2.x) + 

			t * ((2 * p0.x -5 * p1.x +4 * p2.x -p3.x) + 

			t * ( -p0.x +3 * p1.x -3 * p2.x +p3.x)))), 

			0.5 * ((2 * p1.y) + 

			t * (( -p0.y + p2.y) + 

			t * ((2 * p0.y -5 * p1.y +4 * p2.y -p3.y) + 

			t * (  -p0.y +3 * p1.y -3 * p2.y +p3.y)))) 

		); 

	} 

	// generate a random path 

	public function generatePath():void 

	{ 

		trace("Generating AI path"); 

		aiPathWaypoints = [];	 

		var N:int = aiPathWaypointCount; 

		for (var i:int = 0; i < N; i++)  

		{ 

			aiPathWaypoints.push (new Point (aiPathSize * Math.random (), aiPathSize * Math.random ())); 

		} 

	} 

	// find the point on a spline at ratio (0 to 1) 

	public function calculatePathPosition(ratio:Number = 0):Point 

	{ 

		var i:int = int(ratio); 

		var pointratio:Number = ratio - i; 

		//trace(ratio + ' ratio = path point ' + i + ' segment ratio ' + pointratio); 

		var p0:Point = aiPathWaypoints [(i -1 + aiPathWaypoints.length) % aiPathWaypoints.length]; 

		var p1:Point = aiPathWaypoints [i % aiPathWaypoints.length]; 

		var p2:Point = aiPathWaypoints [(i +1 + aiPathWaypoints.length) % aiPathWaypoints.length]; 

		var p3:Point = aiPathWaypoints [(i +2 + aiPathWaypoints.length) % aiPathWaypoints.length]; 

		// figure out current position 

		var q:Point = spline (p0, p1, p2, p3, pointratio); 

		return q; 

	}

	// we could optionally implement many different 

	// versions of this routine with different randomness 

	public function maybeShoot(bulletNum:int = 1,  

		delayMin:Number = NaN,  

		delayMax:Number = NaN):void 

	{ 

		// is it time to shoot a bullet? 

		if (fireTime < age) 

		{ 

			// if delay parameters were not set, use class defaults 

			if (isNaN(delayMin)) delayMin = fireDelayMin; 

			if (isNaN(delayMax)) delayMax = fireDelayMax; 

			// shoot one from the current location 

			gfx.shootBullet(bulletNum, this); 

			// randly choose the next time to shoot 

			fireTime = age + (gfx.fastRandom() * (delayMax - delayMin)) + delayMin; 

		} 

	}

	// moves forward and points at current destination based on speed 

	public function straightAI(seconds:Number):void 

	{ 

		age += seconds; 

		maybeShoot(1); 

		sprite.rotation = gfx.pointAtRad(speedX, speedY) 

			- (90*gfx.DEGREES_TO_RADIANS); 

	}

	// a very simple up/down wobble movement 

	public function wobbleAI(seconds:Number):void 

	{ 

		age += seconds; 

		maybeShoot(1); 

		aiPathOffsetY = (Math.sin(age*2) / Math.PI) * 128;		 

	}

	// simply point at the player: good for sentry guns 

	public function sentryAI(seconds:Number):void 

	{ 

		age += seconds; 

		maybeShoot(3,3,6); 

		if (gfx.thePlayer) 

			sprite.rotation = gfx.pointAtRad( 

				gfx.thePlayer.sprite.position.x - sprite.position.x, 

				gfx.thePlayer.sprite.position.y - sprite.position.y)  

				- (90*gfx.DEGREES_TO_RADIANS); 

	}

	// move around on a random spline path 

	// in future versions, you could upgrade this function 

	// to (instead of random) follow a predefined array of points 

	// that were designed by hand in code (or even in the level editor!) 

	public function droneAI(seconds:Number):void 

	{ 

		//trace('droneAI'); 

		age += seconds; 

		maybeShoot(1); 

		// movement style inspired by Galaga, R-Type, Centipede 

		// performed by easing through a catmull-rom spline curve 

		// defined by an array of points 

		if (aiPathWaypoints == null) 

			generatePath(); 

		// how many spline nodes have we passed? (loops around to beginning) 

		var pathProgress:Number = age / pathNodeTime; 

		var newPos:Point = calculatePathPosition(pathProgress); 

		// point in the correct direction 

		sprite.rotation = gfx.pointAtRad(newPos.x-aiPathOffsetX,newPos.y-aiPathOffsetY)  

			- (90*gfx.DEGREES_TO_RADIANS); 

		// change path offset location 

		// this is added to the sprite scrolling location 

		// so that ships eventually move offscreen 

		// sprite.position.x = newPos.x; 

		// sprite.position.y = newPos.y; 

		aiPathOffsetX = newPos.x; 

		aiPathOffsetY = newPos.x; 

	} 

	} // end class 

} // end package

// Stage3D Shoot-em-up Tutorial Part 4 

// by Christer Kaitila - www.mcfunkypants.com 

// GameLevels.as 

// This class parses .CSV level data strings 

// that define the locations of tiles from a spritesheet 

// Example levels were created using the OGMO editor, 

// but could be designed by hand or any number of other 

// freeware game level editors that can output .csv 

// This can be a .txt, .csv, .oel, .etc file 

// - we will strip all xml/html tags (if any)  

// - we only care about raw csv data 

// Our game can access the current level with: 

// spriteId = myLevel.data[x][y]; 

package 

{ 

	import flash.display3D.Context3DProgramType; 

	public class GameLevels 

	{ 

		// the "demo" level seen during the title screen 

		[Embed(source = '../assets/level0.oel', mimeType = 'application/octet-stream')]  

		private static const LEVEL0:Class; 

		private var level0data:String = new LEVEL0; 

		// the "demo" level background TERRAIN 

		[Embed(source = '../assets/terrain0.oel', mimeType = 'application/octet-stream')]  

		private static const LEVEL0TERRAIN:Class; 

		private var level0terrain:String = new LEVEL0TERRAIN; 

		// the first level that the player actually experiences 

		[Embed(source = '../assets/level1.oel', mimeType = 'application/octet-stream')]  

		private static const LEVEL1:Class; 

		private var level1data:String = new LEVEL1; 

		// the first level background TERRAIN 

		[Embed(source = '../assets/terrain1.oel', mimeType = 'application/octet-stream')]  

		private static const LEVEL1TERRAIN:Class; 

		private var level1terrain:String = new LEVEL1TERRAIN; 

		// the currently loaded level data 

		public var data:Array = []; 

		public function GameLevels() 

		{ 

		}

		private function stripTags(str:String):String 

		{ 

			var pattern:RegExp = /<\/?[a-zA-Z0-9]+.*?>/gim; 

			return str.replace(pattern, ""); 

		} 

		private function parseLevelData(lvl:String):Array 

		{ 

			var levelString:String; 

			var temps:Array; 

			var nextValue:int; 

			var output:Array = []; 

			var nextrow:int; 

			switch (lvl) 

			{ 

				case "level0" : levelString = stripTags(level0data); break; 

				case "terrain0" : levelString = stripTags(level0terrain); break; 

				case "level1" : levelString = stripTags(level1data); break; 

				case "terrain1" : levelString = stripTags(level1terrain); break; 

				default: 

					return output;  

			} 

			//trace("Level " + num + " data:\n" + levelString); 

			var lines:Array = levelString.split(/\r\n|\n|\r/); 

			for (var row:int = 0; row < lines.length; row++) 

			{ 

				// split the string by comma 

				temps = lines[row].split(","); 

				if (temps.length > 1) 

				{ 

					nextrow = output.push([]) - 1; 

					// turn the string values into integers 

					for (var col:int = 0; col < temps.length; col++) 

					{ 

						if (temps[col] == "") temps[col] = "-1"; 

						nextValue = parseInt(temps[col]); 

						if (nextValue < 0) nextValue = -1; // we still need blanks 

						trace('row '+ nextrow + ' nextValue=' + nextValue); 

						output[nextrow].push(nextValue); 

					} 

					//trace('Level row '+nextrow+':\n' + String(output[nextrow])); 

				} 

			} 

			//trace('Level output data:\n' + String(output)); 

			return output; 

		} 

		public function loadLevel(lvl:String):void 

		{ 

			trace("Loading level " + lvl); 

			data = parseLevelData(lvl); 

		} 

	} // end class 

} // end package

// Stage3D Shoot-em-up Tutorial Part 4 

// by Christer Kaitila - www.mcfunkypants.com 

// EntityManager.as 

// The entity manager handles a list of all known game entities. 

// This object pool will allow for reuse (respawning) of 

// sprites: for example, when enemy ships are destroyed, 

// they will be re-spawned when needed as an optimization  

// that increases fps and decreases ram use. 

package 

{ 

	import flash.display.Bitmap; 

	import flash.display3D.*; 

	import flash.geom.Point; 

	import flash.geom.Rectangle; 

	public class EntityManager 

	{ 

		// the level data parser 

		public var level:GameLevels; 

		// the current level number 

		public var levelNum:int = 0; 

		// where in the level we are in pixels 

		public var levelCurrentScrollX:Number = 0; 

		// the last spawned column of level data 

		public var levelPrevCol:int = -1; 

		// pixels we need to scroll before spawning the next col 

		public var levelTilesize:int = 48; 

		// this is used to ensure all terrain tiles line up exactly 

		public var lastTerrainEntity:Entity; 

		// we need to allow at least enough space for ship movement 

		// entities that move beyond the edges of the screen 

		// plus this amount are recycled (destroyed for reuse) 

		public var cullingDistance:Number = 200; 

		// a particle system class that updates our sprites 

		public var particles:GameParticles; 

		// so that explosions can be played 

		public var sfx:GameSound; 

		// the sprite sheet image 

		public var spriteSheet : LiteSpriteSheet; 

		public var SpritesPerRow:int = 8; 

		public var SpritesPerCol:int = 8; 

		// we no longer force a particular spritesheet here 

		//[Embed(source="../assets/sprites.png")] 

		//private var SourceImage : Class; 

		public var SourceImage : Class; 

		// the general size of the player and enemies 

		public var defaultScale:Number = 1; 

		// how fast the default scroll (enemy flying) speed is 

		public var defaultSpeed:Number = 128; 

		// how fast player bullets go per second 

		public var bulletSpeed:Number = 250; 

		// for framerate-independent timings 

		public var currentFrameSeconds:Number = 0; 

		// sprite IDs (indexing the spritesheet) 

		public const spritenumFireball:uint = 63; 

		public const spritenumFireburst:uint = 62; 

		public const spritenumShockwave:uint = 61; 

		public const spritenumDebris:uint = 60; 

		public const spritenumSpark:uint = 59; 

		public const spritenumBullet3:uint = 58; 

		public const spritenumBullet2:uint = 57; 

		public const spritenumBullet1:uint = 56; 

		public const spritenumPlayer:uint = 10; 

		public const spritenumOrb:uint = 17; 

		// reused for calculation speed 

		public const DEGREES_TO_RADIANS:Number = Math.PI / 180; 

		public const RADIANS_TO_DEGREES:Number = 180 / Math.PI; 

		// the player entity - a special case 

		public var thePlayer:Entity; 

		// a "power orb" that orbits the player 

		public var theOrb:Entity; 

		// a reusable pool of entities 

		// this contains every known Entity 

		// including the contents of the lists below 

		public var entityPool : Vector.<Entity>; 

		// these pools contain only certain types 

		// of entity as an optimization for smaller loops  

		public var allBullets : Vector.<Entity>; 

		public var allEnemies : Vector.<Entity>; 

		// all the polygons that make up the scene 

		public var batch : LiteSpriteBatch; 

		// for statistics 

		public var numCreated : int = 0; 

		public var numReused : int = 0; 

		public var maxX:int; 

		public var minX:int; 

		public var maxY:int; 

		public var minY:int; 

		public var midpoint:int;

		public function EntityManager(view:Rectangle) 

		{ 

			entityPool = new Vector.<Entity>(); 

			allBullets = new Vector.<Entity>(); 

			allEnemies = new Vector.<Entity>(); 

			particles = new GameParticles(this); 

			setPosition(view);	 

			level = new GameLevels(); 

		} 

		public function setPosition(view:Rectangle):void  

		{ 

			// allow moving fully offscreen before 

			// automatically being culled (and reused) 

			maxX = view.width + cullingDistance; 

			minX = view.x - cullingDistance; 

			maxY = view.height + cullingDistance; 

			minY = view.y - cullingDistance; 

			midpoint = view.height / 2; 

		} 

		// this XOR based fast random number generator runs 4x faster 

		// than Math.random() and also returns a number from 0 to 1 

		// see http://www.calypso88.com/?cat=7 

		private const FASTRANDOMTOFLOAT:Number = 1 / uint.MAX_VALUE; 

		private var fastrandomseed:uint = Math.random() * uint.MAX_VALUE; 

		public function fastRandom():Number 

		{ 

			fastrandomseed ^= (fastrandomseed << 21); 

			fastrandomseed ^= (fastrandomseed >>> 35); 

			fastrandomseed ^= (fastrandomseed << 4); 

			return (fastrandomseed * FASTRANDOMTOFLOAT); 

		}

		public function createBatch(context3D:Context3D, uvPadding:Number=0) : LiteSpriteBatch  

		{ 

			var sourceBitmap:Bitmap = new SourceImage(); 

			// create a spritesheet with 8x8 (64) sprites on it 

			spriteSheet = new LiteSpriteSheet(sourceBitmap.bitmapData, SpritesPerRow, SpritesPerCol, uvPadding); 

			// Create new render batch  

			batch = new LiteSpriteBatch(context3D, spriteSheet); 

			return batch; 

		}

		// search the entity pool for unused entities and reuse one 

		// if they are all in use, create a brand new one 

		public function respawn(sprID:uint=0):Entity 

		{ 

			var currentEntityCount:int = entityPool.length; 

			var anEntity:Entity; 

			var i:int = 0; 

			// search for an inactive entity 

			for (i = 0; i < currentEntityCount; i++ )  

			{ 

				anEntity = entityPool[i]; 

				if (!anEntity.active && (anEntity.sprite.spriteId == sprID)) 

				{ 

					//trace('Reusing Entity #' + i); 

					anEntity.active = true; 

					anEntity.sprite.visible = true; 

					anEntity.recycled = true; 

					numReused++; 

					return anEntity; 

				} 

			} 

			// none were found so we need to make a new one 

			//trace('Need to create a new Entity #' + i); 

			var sprite:LiteSprite; 

			sprite = batch.createChild(sprID); 

			anEntity = new Entity(sprite, this); 

			entityPool.push(anEntity); 

			numCreated++; 

			return anEntity; 

		} 

		// this entity is the PLAYER 

		public function addPlayer(playerController:Function):Entity  

		{ 

			trace("Adding Player Entity"); 

			thePlayer = respawn(spritenumPlayer); 

			thePlayer.sprite.position.x = 64; 

			thePlayer.sprite.position.y = midpoint; 

			thePlayer.sprite.rotation = 180 * DEGREES_TO_RADIANS; 

			thePlayer.sprite.scaleX = thePlayer.sprite.scaleY = defaultScale;  

			thePlayer.speedX = 0; 

			thePlayer.speedY = 0; 

			thePlayer.active = true; 

			thePlayer.collidemode = 1; 

			thePlayer.collideradius = 10; 

			thePlayer.owner = thePlayer; // collisions require this 

			thePlayer.aiFunction = playerController; 

			// just for fun, spawn an orbiting "power orb" 

			theOrb = respawn(spritenumOrb); 

			theOrb.rotationSpeed = 720 * DEGREES_TO_RADIANS; 

			theOrb.sprite.scaleX = theOrb.sprite.scaleY = defaultScale / 2; 

			theOrb.leavesTrail = true; 

			theOrb.collidemode = 1; 

			theOrb.collideradius = 12; 

			theOrb.isBullet = true; 

			theOrb.owner = thePlayer; 

			theOrb.orbiting = thePlayer; 

			theOrb.orbitingDistance = 180; 

			return thePlayer; 

		}		 

		// shoot a bullet 

		public function shootBullet(powa:uint=1, shooter:Entity = null):Entity  

		{ 

			// just in case the AI is running during the main menu 

			// and we've not yet created the player entity 

			if (thePlayer == null) return null; 

			var theBullet:Entity; 

			// assume the player shot it 

			// otherwise maybe an enemy did 

			if (shooter == null)  

				shooter = thePlayer; 

			// three possible bullets, progressively larger 

			if (powa == 1)  

				theBullet = respawn(spritenumBullet1); 

			else if (powa == 2)  

				theBullet = respawn(spritenumBullet2); 

			else  

				theBullet = respawn(spritenumBullet3); 

			theBullet.sprite.position.x = shooter.sprite.position.x + 8; 

			theBullet.sprite.position.y = shooter.sprite.position.y + 2; 

			theBullet.sprite.rotation = 180 * DEGREES_TO_RADIANS; 

			theBullet.sprite.scaleX = theBullet.sprite.scaleY = 1;  

			if (shooter == thePlayer) 

			{ 

				theBullet.speedX = bulletSpeed; 

				theBullet.speedY = 0; 

			} 

			else // enemy bullets move slower and towards the player 

			{ 

				theBullet.sprite.rotation =  

					pointAtRad(theBullet.sprite.position.x - thePlayer.sprite.position.x, 

						theBullet.sprite.position.y-thePlayer.sprite.position.y) - (90*DEGREES_TO_RADIANS); 

				// move in the direction we're facing 

				theBullet.speedX = defaultSpeed*1.5*Math.cos(theBullet.sprite.rotation); 

				theBullet.speedY = defaultSpeed*1.5*Math.sin(theBullet.sprite.rotation); 

				// optionally, we could just fire straight ahead in the direction we're heading: 

				// theBullet.speedX = shooter.speedX * 1.5; 

				// theBullet.speedY = shooter.speedY * 1.5; 

				// and we could point where we're going like this: 

				// pointAtRad(theBullet.speedX,theBullet.speedY) - (90*DEGREES_TO_RADIANS); 

			} 

			theBullet.owner = shooter; 

			theBullet.collideradius = 10; 

			theBullet.collidemode = 1; 

			theBullet.isBullet = true; 

			if (!theBullet.recycled) 

				allBullets.push(theBullet); 

			return theBullet; 

		}		 

		// Unused: this was "addEntities()" in the previous tutorials. 

		// It spawns random enemies that move in a straight line 

		public function addRandomEntity():void 

		{ 

			var anEntity:Entity; 

			var sprID:int; 

			sprID = Math.floor(fastRandom() * 55); 

			// try to reuse an inactive entity (or create a new one) 

			anEntity = respawn(sprID); 

			// give it a new position and velocity 

			anEntity.sprite.position.x = maxX; 

			anEntity.sprite.position.y = fastRandom() * maxY; 

			anEntity.speedX = 15 * ((-1 * fastRandom() * 10) - 2); 

			anEntity.speedY = 15 * ((fastRandom() * 5) - 2.5); 

			anEntity.sprite.scaleX = defaultScale; 

			anEntity.sprite.scaleY = defaultScale; 

			anEntity.sprite.rotation = pointAtRad(anEntity.speedX,anEntity.speedY) - (90*DEGREES_TO_RADIANS); 

			anEntity.collidemode = 1; 

			anEntity.collideradius = 16; 

			if (!anEntity.recycled) 

				allEnemies.push(anEntity); 

		} 

		// returns the angle in radians of two points 

		public function pointAngle(point1:Point, point2:Point):Number 

		{ 

			var dx:Number = point2.x - point1.x; 

			var dy:Number = point2.y - point1.y; 

			return -Math.atan2(dx,dy); 

		}		 

		// returns the angle in degrees of 0,0 to x,y 

		public function pointAtDeg(x:Number, y:Number):Number 

		{ 

			return -Math.atan2(x,y) * RADIANS_TO_DEGREES; 

		}		 

		// returns the angle in radians of 0,0 to x,y 

		public function pointAtRad(x:Number, y:Number):Number 

		{ 

			return -Math.atan2(x,y); 

		}		 

		// as an optimization to saver millions of checks, only 

		// the player's bullets check for collisions with all enemy ships 

		// (enemy bullets only check to hit the player) 

		public function checkCollisions(checkMe:Entity):Entity 

		{ 

			var anEntity:Entity; 

			var collided:Boolean = false; 

			if (checkMe.owner != thePlayer) 

			{	// quick check ONLY to see if we have hit the player 

				anEntity = thePlayer; 

				if (checkMe.colliding(anEntity))  

				{ 

					trace("Player was HIT!"); 

					collided = true; 

				} 

			} 

			else // check all active enemies 

			{ 

				for(var i:int=0; i< allEnemies.length;i++) 

				{ 

					anEntity = allEnemies[i]; 

					if (anEntity.active && anEntity.collidemode) 

					{ 

						if (checkMe.colliding(anEntity))  

						{ 

							collided = true; 

							break; 

						} 

					} 

				} 

			} 

			if (collided) 

			{ 

				//trace('Collision!'); 

				if (sfx) sfx.playExplosion(int(fastRandom() * 2 + 1.5)); 

				particles.addExplosion(checkMe.sprite.position); 

				if ((checkMe != theOrb) && (checkMe != thePlayer))  

					checkMe.die(); // the bullet 

				if ((anEntity != theOrb) && ((anEntity != thePlayer)))  

					anEntity.die(); // the victim 

				return anEntity; 

			} 

			return null; 

		}

		// called every frame: used to update the simulation 

		// this is where you would perform AI, physics, etc. 

		// in this version, currentTime is seconds since the previous frame 

		public function update(currentTime:Number) : void 

		{		 

			var anEntity:Entity; 

			var i:int; 

			var max:int; 

			// what portion of a full second has passed since the previous update? 

			currentFrameSeconds = currentTime / 1000; 

			// handle all other entities 

			max = entityPool.length; 

			for (i = 0; i < max; i++) 

			{ 

				anEntity = entityPool[i]; 

				if (anEntity.active) 

				{ 

					// subtract the previous aiPathOffset 

					anEntity.sprite.position.x -= anEntity.aiPathOffsetX; 

					anEntity.sprite.position.y -= anEntity.aiPathOffsetY; 

					// calculate location on screen with scrolling 

					anEntity.sprite.position.x += anEntity.speedX * currentFrameSeconds;