Pong in Flash

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.
}