stop();

//Create globals, actionlisteners
var xInitialCoordinate: int = stage.stageWidth / 2;
var yInitialCoordinate: int = stage.stageHeight / 2;
var xMoveSpeed: int = 5;
var yMoveSpeed: int = 5;
var scorePOne:int = 0;
var scorePTwo: int = 0;
var numberConsecutiveCollisions: int = 0;

//Levels - you need to adjust the render method if you want to change this
var levelCount: int = 5;
var levelSpeeds: Array = new Array(levelCount);
levelSpeeds[0] = new Array(5,5);
levelSpeeds[1] = new Array(6,6);
levelSpeeds[2] = new Array(7,7);
levelSpeeds[3] = new Array(8,8);
levelSpeeds[4] = new Array(9,11); //This'll be a tricky one.



//Dimensions of the various sprites
var ballHeight:int = 10;
var ballWidth:int = 10;
var paddleHeight:int = 50;
var paddleWidth:int = 20;

stage.addEventListener(KeyboardEvent.KEY_DOWN, keyDownEvent);
stage.addEventListener(Event.ENTER_FRAME, render);

//Let's start this up, formatting and such.
init();

//Function (or method if you like) to handle keyevents, move paddles.
//KEY IS DOWN, I REPEAT, KEY IS DOWN!! REQUESTING BACKUP!!

//We use the arrowkeys and WASD (Well, only WS) for paddlemovement.
function keyDownEvent(evt: KeyboardEvent): void {
	
	// We know that this'll be an int, because evt.keyCode will return the
	// decimal value of the ascii char which
	// represents the key pressed
   var tastekode: int = evt.keyCode;
   switch(tastekode){
	   case Keyboard.DOWN:
	   		paddleRight.y += 30;
			break;
		case Keyboard.UP:
			paddleRight.y -= 30;
			break;
		case Keyboard.S:
			paddleLeft.y += 30;
			break;
		case Keyboard.W:
			paddleLeft.y -= 30;
			break;
		default:
			break;
   }
}

//Initfunction which sets up the environment nicely.
function init(): void{
	ball.x = xInitialCoordinate;
	ball.y = yInitialCoordinate;
	ball.width = ballWidth;
	ball.height = ballHeight;
	
	paddleLeft.width = paddleWidth;
	paddleLeft.height = paddleHeight;
	paddleRight.width = paddleWidth;
	paddleRight.height = paddleHeight;
	
	dottedLine.x = xInitialCoordinate;
	dottedLine.y = 0;
	
	var tf:TextFormat = new TextFormat(); 
	tf.color = 0xFFFFFF; 
	tf.size = 30;
	/* Apply this specific text format to the Label instance. */ 
	scorePlayerOne.setStyle("textFormat", tf);
	scorePlayerTwo.setStyle("textFormat", tf);
}

function updateGameScore(whotoupdate: int): void{
	if(whotoupdate == 1){
		scorePOne++;
		scorePlayerOne.text = scorePOne.toString();
	} else if (whotoupdate == 2){
		scorePTwo++;
		scorePlayerTwo.text = scorePTwo.toString();
	}
	
	numberConsecutiveCollisions = 0;
	ball.x = xInitialCoordinate;
	ball.y  = yInitialCoordinate;
}

//This is triggered for each new frame pushed by Flash,
//effectively updating the gamescreen.
function render(evt: Event): void{
	
	if (ball.y < 0 || (ball.y + ballHeight) > stage.stageHeight){
		yMoveSpeed = -yMoveSpeed;
	}
	
	//This could've been done nicer, definately.
	switch(numberConsecutiveCollisions){
		case 0:
			if(yMoveSpeed < 0){
				yMoveSpeed = -levelSpeeds[0][0];
			} else {
				yMoveSpeed = levelSpeeds[0][0];
			}
			
			if(xMoveSpeed < 0){
				xMoveSpeed = -levelSpeeds[0][1];
			} else {
				xMoveSpeed = levelSpeeds[0][1];
			}
			
			break;
		case 2:
			if(yMoveSpeed < 0){
				yMoveSpeed = -levelSpeeds[1][0];
			} else {
				yMoveSpeed = levelSpeeds[1][0];
			}
			
			if(xMoveSpeed < 0){
				xMoveSpeed = -levelSpeeds[1][1];
			} else {
				xMoveSpeed = levelSpeeds[1][1];
			}
			
			break;
		case 5:
			if(yMoveSpeed < 0){
				yMoveSpeed = -levelSpeeds[2][0];
			} else {
				yMoveSpeed = levelSpeeds[2][0];
			}
			
			if(xMoveSpeed < 0){
				xMoveSpeed = -levelSpeeds[3][1];
			} else {
				xMoveSpeed = levelSpeeds[3][1];
			}
			
			break;
		case 10:
			if(yMoveSpeed < 0){
				yMoveSpeed = -levelSpeeds[4][0];
			} else {
				yMoveSpeed = levelSpeeds[4][0];
			}
			
			if(xMoveSpeed < 0){
				xMoveSpeed = -levelSpeeds[4][1];
			} else {
				xMoveSpeed = levelSpeeds[4][1];
			}
			
			break;
		default:
			break;
	}
	
	//Ball goes out of bounds to left and right.
	if((ballWidth + ball.x) < 0 ){
		updateGameScore(2);
	} else if( ball.x > stage.stageWidth){
		updateGameScore(1);
	}
	
	//trace(stage.stageHeight + " " + ball.y  + " " + yMoveSpeed );
	
	//Block paddles
	if(paddleLeft.y <= 0){
		paddleLeft.y = 0;
	} else if((paddleLeft.y + paddleHeight) >= stage.stageHeight){
		paddleLeft.y = stage.stageHeight - paddleHeight;
	} else if(paddleRight.y <= 0){
		paddleRight.y = 0;
	} else if((paddleRight.y + paddleHeight) >= stage.stageHeight){
		paddleRight.y = stage.stageHeight - paddleHeight;
	}
	
	//hitTestObject tends to act weird, should look into this.
	if(ball.hitTestObject(paddleRight) || ball.hitTestObject(paddleLeft)){
	   xMoveSpeed = -xMoveSpeed;
	   numberConsecutiveCollisions++;
	}
	
	ball.x += xMoveSpeed;
	ball.y += yMoveSpeed;
	//Logic done. Now we don't need to use *that* anymore.
}