I'm sure someone else would have something more elegant but this is some code I dug up out of an old project of my own for what sounds like a similar game, so it does work :p

// This rectangle defines your screen size. Replace 640x480 with the size of your Flash app.
// We will spawn enemies just outside this rectangle.
var _screenRect:Rectangle = new Rectangle(0, 0, 640, 480);

// This rectangle defines the range of positions enemies should spawn in. It will be adjusted
// to match the size of the enemy being spawned during the set position method.
var _spawnRect:Rectangle = new Rectangle();

// Return a random number between min and max.
private function RandomWithinRange(min:Number, max:Number):Number
{
	return Math.random() * (max - min) + min;
}

// Send a sprite class to this to move it off the screen.
private function MoveOffscreen(enemy:Sprite):void
{
	var spawnX:Number;
	var spawnY:Number;
	
	// We set the spawn rectangle to the size of the screen but
	// expand it out by the size of the object being spawned.
	// This will allow enemies of any size to always be moved off screen.
	var padX:Number = enemy.width;
	var padY:Number = enemy.height;
	
	_spawnRect.x = _screenRect.x - padX;
	_spawnRect.width = _screenRect.width + padX;
	_spawnRect.y = _screenRect.y - padY;
	_spawnRect.height = _screenRect.height + padY;
	
	// Pick randomly between X and Y, and move the spawn position to the full extent on
	// that axis. Then randomise the other axis.
	if (Math.random() > 0.5)
	{
		// We are setting the X to its full distance on the left or right, randomly pick which
		if (Math.random() > 0.5)
		{
			// left
			spawnX = _spawnRect.x;
		}
		else
		{
			// right
			spawnX = _spawnRect.width;
		}
		// Randomise the other axis.
		spawnY = RandomWithinRange(_spawnRect.y, _spawnRect.height);
	}
	else
	{
		// We are setting the Y to its full distance up or down, randomly pick which
		if (Math.random() > 0.5)
		{
			// Up
			spawnY = _spawnRect.y;
		}
		else
		{
			// down
			spawnY = _spawnRect.height;
		}
		// Randomise the other axis.
		spawnX = RandomWithinRange(_spawnRect.x, _spawnRect.width);
	}
	
	// Move the enemy to the new position
	enemy.x = spawnX;
	enemy.y = spawnY;
}

If you're using a generic Sprite instance for creating instance of enemy, you're limiting what they'll be able to do (not to mention making your code unnecessarily complex). So if you're not already doing so I'd recommend making the enemy a class of its own...something like this (note that you'll have to update the package, and maybe the class name if you can't use or don't like "Enemy"):

[source]

package your.package.path {

import flash.display.Sprite;

import flash.geom.Rectangle;

import flash.events.Event;

public class Enemy extends Sprite {

private var _excArea:Rectangle;

public function Enemy(spawnExclusionArea:Rectangle) {

this._excArea=spawnExclusionArea;

//Ensure that enemy is on the stage before trying to update its position...

this.addEventListener(Event.ADDED_TO_STAGE, this.placeEnemy);

}

private function placeEnemy(eventObj:Event):void {

this.removeEventListener(Event.ADDED_TO_STAGE, this.placeEnemy);

this.x=this.getExcludedPoint("x");

this.y=this.getExcludedPoint("y");

}

function getExcludedPoint(axis:String):Number {
if (Math.random()<=0.5) {
if (axis=="x") {

}

[/source]

Using an Enemy class will allow you to extend your code to create custom enemies (with custom behaviours, graphics, etc.):

[source]

package your.package.path {

import your.package.path.Enemy;

public class Boss extends Enemy {

...

[/source]

Note that in the exclusion area calculations we have to use stageWidth and stageHeight instead of the stage's width/height properties (these tell us the dimensions of all of the content on the stage, which typically aren't the dimensions of the whole stage area). If you want a larger or smaller display area (for example, your game doesn't take up the entire stage), change the stageWidth and stageHeight values to your maximum viewable area.

In the class that spawns your enemies, creating a randomly placed enemy is very simple:

[source]

[/source]

Because the random placement is done in the Enemy class constructor, this is literally all that's needed. The createEnemy function returns the new Enemy instance, but that's entirely optional.

If you wanted to keep track of all active enemies, you could extend the Enemy class to track itself using a static variable:

[source]

public class Enemy extends Sprite {

private static var _enemies:Vector.<Enemy>=new Vector.<Enemy>();

private var _excArea:Rectangle;

public function Enemy(spawnExclusionArea:Rectangle) {

this._excArea=spawnExclusionArea;

//Ensure that enemy is on the stage before trying to update its position...

this.addEventListener(Event.ADDED_TO_STAGE, this.placeEnemy);

this.addEventListener(Event.REMOVED_FROM_STAGE, this.removeEnemy);

}

private function placeEnemy(eventObj:Event):void {

this.removeEventListener(Event.ADDED_TO_STAGE, this.placeEnemy);

this.x=this.getExcludedPoint("x");

this.y=this.getExcludedPoint("y");

this.addEnemyToList();

}

private function removeEnemy(eventObj:Event):void {

this.removeEventListener(Event.ADDED_TO_STAGE, this.removeEnemy);

this.removeEnemyFromList();

}

private function addEnemyToList():void {

_enemies.push(this);

}

private function removeEnemyFromList():void {

var compactVector:Vector.<Enemy>=new Vector.<Enemy>();

for (var count:uint=0; count<_enemies.length; count++) {

var currentEnemy:Enemy=_enemies[count];

if (currentEnemy!=this) {

compactVector.push(currentEnemy)

}

}

_enemies=compactVector;

}

public static function get enemies():Vector.<Enemy> {

return (_enemies);

}

function getExcludedPoint(axis:String):Number {
if (Math.random()<=0.5) {

}

[/source]