Pong - Flash (11/01/2013)

// Pong
// (c)2012 Cèsar Rincón Nadal
// EMAID - Escola d'art i diseny de Vilanova


/*
    Notas del profe
    Hay algun bug en el rebote inferior a la derecha, estoy en ello, pero podeis ir mirando ya el codigo.
*/

/*
    Juego
*/



/*
    Importa los archivos de clases necesarios
*/

import flash.utils.Timer;
import flash.events.TimerEvent;
import flash.events.KeyboardEvent;
import emaid.commons.CTools;
import emaid.classes.CPong;




/*
    Variables globales y creacion de clases
*/

// Crea el objeto Tools de la Clase CTools
var Tools = new CTools();

// Variables
var playerSpeed:Number = 15;        // Velocidad del jugador
var ballSpeedX:Number;              // Velocidades X e Y de la bola
var ballSpeedY:Number;
var ballStartSpeed:Number = 5;
var cpuSeekDistance:Number = 250;   // Distancia de seguimiento (X)
var cpuMoveSpeed:Number = 15;       // Velocidad de movimiento de la Cpu
var ballMaxSpeed:Number = 0;        // Velocidad maxima de la bola
var ballSpeedAcc:Number = 1;        // Incremento de velocidad a cada rebote
var ballOldposX:Number;             // Guarda la posicion antes de desplazarte
var ballOldposY:Number;
var playerScore:Number = 0;         // Puntuacion del jugador
var cpuScore:Number = 0;            // Puntuacion de la CPU
var matchPoints:Number = 9;         // Numero de puntos para ganar el juego
var playGame:Boolean = false;       // Control de la pausa del juego
var gameOver:Boolean = false;       // Flag de Game Over
var spaceKeyShow:Boolean = false;   // Flag de visualizacion de el mensage Space Key
var spaceKeyTimer:Number = 0;       // Control de tiempo entre parpadeos del mensage de SpaceKey


/*
    Bloque de Update
*/

// Define el Timer a 30 fps
var myTimer:Timer = new Timer(1000/30);
// Crea el listener
myTimer.addEventListener(TimerEvent.TIMER, Update);
// Funcion Update
function Update(e:TimerEvent) {
    /*
        >>> (Todo el codigo que se actualiza en cada frame, va aqui <<<
    */

    if (playGame) {
        // Si no hay pausa
        MoveBall();             // Mueve la bola
        MovePlayer();           // Mueve la pala del jugador
        // Si es juego single player...
        if (CPong.playerNum == 1) {
            CpuIa();            // Mueve la pala de la CPU
        } else {
            MoveVersus();       // El player 2 mueve la segunda pala
        }
        PalasCollision();       // Detecta si la bola colisiona con alguna de las palas
    } else {
        // Si estas en pausa, espera a que se presione espacio
        if (Tools.kSpace) {
            // Si es el fin de juego, vuelve al menu
            if (gameOver) {
                // Deten el Timer
                myTimer.stop();
                // Elimina todos los eventos declarados
                PongCleanUpEvents();
                // Vuelve al menu
                gotoAndStop(1);
            } else {
                // Si no, continua la partida
                playGame = true;
            }
        }
        // Gestion del mensage de Press Space Key
        PressSpaceKeyMessage();
    }

}



/*
    Bloque de declaracion de funciones
*/

// Control del teclado mediante los eventos KEY_UP y KEY_DOWN
// Al presionar una tecla...
stage.addEventListener(KeyboardEvent.KEY_DOWN, KeyDown);
function KeyDown(e:KeyboardEvent):void {
    // Al presionar cualquier tecla, llama a la funcion KeysDown de la Clase CTools
    Tools.KeysDown(e.keyCode);
}
// Al soltar una tecla...
stage.addEventListener(KeyboardEvent.KEY_UP, KeyUp);
function KeyUp(e:KeyboardEvent):void {
    // Al soltar cualquier tecla, llama a la funcion KeysUp de la Clase CTools
    Tools.KeysUp(e.keyCode);
}


// Movimiento de la pala del jugador
function MovePlayer():void {
    // Si se presiona arriba
    if (Tools.kUp) {
        palaA.y -= playerSpeed;
        // Limites
        if (palaA.y <= 20) palaA.y = 20;
    }
    // Si se presiona abajo
    if (Tools.kDown) {
        palaA.y += playerSpeed;
        // Limites
        if (palaA.y >= (580 - palaA.height)) palaA.y = (580 - palaA.height);
    }
}


// Movimiento de la pala del jugador 2 (Versus)
function MoveVersus():void {
    // Variables privadas
    var mousePos = (stage.mouseY - (palaB.height / 2));
    // Si el puntero del mouse esta mas arriba
    if (mousePos < palaB.y) {
        palaB.y -= playerSpeed;
        // Limites
        if (palaB.y <= 20) palaB.y = 20;
    }
    // Si el puntero del mouse esta mas abajo
    if (mousePos > palaB.y) {
        palaB.y += playerSpeed;
        // Limites
        if (palaB.y >= (580 - palaB.height)) palaB.y = (580 - palaB.height);
    }
}


// Funcion CpuIa
function CpuIa():void {

    // Variables privadas
    var ballY:Number = (ball.y + (ball.height / 2));    // Coordenada Y central de la bola
    var palaY:Number = (palaB.y + (palaB.height / 2));  // Coordenada Y central de la pala B
    var mySpeed:Number = cpuMoveSpeed;

    // Primer check, si la bola se esta acercando...
    if ((ballSpeedX > 0) && (ball.x > cpuSeekDistance)) {
        // Si la bola esta mas arriba, sube
        if (ballY < palaY) {
            // Compensa la velocidad a la baja si es necesario
            if ((palaY - ballY) < mySpeed) mySpeed = (palaY - ballY);
            // Mueve la pala
            palaB.y -= mySpeed;
            // Limites
            if (palaB.y <= 20) palaB.y = 20;
        }
        // Si la bola esta mas abajo
        if (ballY > palaY) {
            // Compensa la velocidad a la baja si es necesario
            if ((ballY - palaY) < mySpeed) mySpeed = (ballY - palaY);
            // Mueve la pala
            palaB.y += mySpeed;
            // Limites
            if (palaB.y >= (580 - palaB.height)) palaB.y = (580 - palaB.height);
        }
    }

}


// Movimiento de la bola
function MoveBall():void {

    // Variables
    var distanceX:Number;   // Vector de distancia entre los dos frames
    var distanceY:Number;
    var pointX:Number;      // Punto de colision
    var pointY:Number;
    var pathX:Number;       // Punto X donde la pelota a impactado contra la pared
    var top:Number = 10;    // Limites superior e inferior
    var bottom:Number = (590 - ball.height);
    var left:Number = 0;    // Limites izquierdo y derecho
    var right:Number = (800 - ball.width);

    // Guarda la posicion actual
    BackupBallPos();

    // Mueve la bola en ambos ejes
    ball.x += ballSpeedX;
    ball.y += ballSpeedY;

    // Si tocas la parte superior...
    if (ball.y < top) {
        // Calcula la distancia Y entre los dos frames
        distanceY = (ballOldposY - ball.y);
        // Segun la direccion de la pelota...
        if (ballOldposX > ball.x) {
            // Calcula el punto de impacto
            distanceX = (ballOldposX - ball.x);     // Distancia X entre los 2 frames
            pointY = (top - ball.y);                // Punto Y del vector donde se produce el impacto
            pointX = ((pointY * distanceX) / distanceY);    // Calculo del punto X del vector donde hay el impacto
            pathX = (ball.x + pointX);      // Calcula la coordenada X real donde deberia de estar la bola
        } else {
            // Calcula el punto de impacto
            distanceX = (ball.x - ballOldposX);     // Distancia X entre los 2 frames
            pointY = (ballOldposY - top);               // Punto Y del vector donde se produce el impacto
            pointX = ((pointY * distanceX) / distanceY);    // Calculo del punto X del vector donde hay el impacto
            pathX = (ballOldposX + pointX);     // Calcula la coordenada X real donde deberia de estar la bola
        }
        // Recoloca la bola
        ball.x = pathX;
        ball.y = top;
        ballSpeedY = -ballSpeedY;
    }

    // Si tocas la parte inferior...
    if (ball.y > bottom) {
        // Calcula la distancia Y entre los dos frames
        distanceY = (ballOldposY - ball.y);
        // Segun la direccion de la pelota...
        if (ballOldposX > ball.x) {
            // Calcula el punto de impacto
            distanceX = (ballOldposX - ball.x);     // Distancia X entre los 2 frames
            pointY = (ball.y - bottom);             // Punto Y del vector donde se produce el impacto
            pointX = ((pointY * distanceX) / distanceY);    // Calculo del punto X del vector donde hay el impacto
            pathX = (ball.x + pointX);      // Calcula la coordenada X real donde deberia de estar la bola
        } else {
            // Calcula el punto de impacto
            distanceX = (ball.x - ballOldposX);     // Distancia X entre los 2 frames
            pointY = (bottom - ballOldposY);                // Punto Y del vector donde se produce el impacto
            pointX = ((pointY * distanceX) / distanceY);    // Calculo del punto X del vector donde hay el impacto
            pathX = (ballOldposX + pointX);     // Calcula la coordenada X real donde deberia de estar la bola
        }
        // Recoloca la bola
        ball.x = pathX;
        ball.y = bottom;
        ballSpeedY = -ballSpeedY;
    }

    // Si tocas la parte derecha o izquierda del decorado...
    if (ball.x <= left) {
        ball.x = left;
        ballSpeedX = -ballSpeedX;
        SetPoint(false);    // Punto para la CPU
    }
    if (ball.x >= right) {
        ball.x = right;
        ballSpeedX = -ballSpeedX;
        SetPoint(true);     // Punto para el Player
    }

}


// Funcion de Backup de la posicion de la bola
function BackupBallPos():void {
    // Guarda la posicion actual de la bola
    ballOldposX = ball.x;
    ballOldposY = ball.y;
}


// Funcion de deteccion de colisiones con las palas
function PalasCollision():void {

    // Variables privadas
    var ballY:Number = 0;               // Posicion Y de la bola
    var palY:Number = 0;                // Posicion Y de la pala
    var palSize:Number = 0;             // Tamaño de la pala
    var collision:Boolean = false;      // Si a habido colision
    var maxX:Number;        // Valores maximos para el calculo de trayectoria
    var maxY:Number;
    var limitXA:Number = (palaA.x + palaA.width);   // Linea limite de la pala A (Zona de colision)
    var limitXB:Number = (palaB.x - ball.width);    // Linea limite de la pala B (Zona de colision)
    var pointX:Number;                              // Punto de analisis para la interpolacion de la trayectoria
    var pointY:Number;
    var distanceX:Number;               // Distancia recorrida en los ultimos 2 frames
    var distanceY:Number;
    var pathY:Number;       // Punto de interseccion entre la bola y la pala en la coordenada Y

    // Si la bola va hacia la izquierda y colisiona con la pala A
    if ((ballSpeedX < 0) && (ballOldposX >= limitXA) && (ball.x <= limitXA)) {
        // Posible colision con la pala, analiza la trayectoria...
        distanceX = ballOldposX - ball.x;                   // Calcula la distancia sobre el eje X
        if (ballOldposY > ball.y) {                         // Segun que posicion Y sea mayor...
            distanceY = (ballOldposY - ball.y);             // Calcula la distancia sobre el eje Y
            pointX = (limitXA - ball.x);                    // Segun la direccion de la bola, calcula el punto X para el test
            pointY = ((pointX * distanceY) / distanceX);    // Ahora ya puedes calcular el punto Y de la trayectoria
            pathY = (ball.y + pointY);
        } else {
            distanceY = (ball.y - ballOldposY);             // Calcula la distancia sobre el eje Y
            pointX = (ballOldposX - limitXA);               // Segun la direccion de la bola, calcula el punto X para el test
            pointY = ((pointX * distanceY) / distanceX);    // Ahora ya puedes calcular el punto Y de la trayectoria
            pathY = (ballOldposY + pointY);
        }

        // Si hay colision...
        if (((pathY + ball.height) >= palaA.y) && (pathY <= (palaA.y + palaA.height))) {
            // Recoloca la bola
            ball.x = (palaA.x + palaA.width);
            ball.y = pathY;
            // Invierte el sentido de la bola
            ballSpeedX = -ballSpeedX;
            // Registra la posicion de la pala e indica que a habido una colision
            palY = (palaA.y + (palaA.height / 2));
            palSize = palaA.height;
            collision = true;
        }
    }

    // Si la bola va hacia la derecha y colisiona con la pala B
    if ((ballSpeedX > 0) && (ballOldposX <= limitXB) && (ball.x >= limitXB)) {
        // Posible colision con la pala, analiza la trayectoria...
        distanceX = ball.x - ballOldposX;                   // Calcula la distancia sobre el eje X
        if (ballOldposY > ball.y) {                         // Segun que posicion Y sea mayor...
            distanceY = (ballOldposY - ball.y);             // Calcula la distancia sobre el eje Y
            pointX = (ball.x - limitXB);                    // Segun la direccion de la bola, calcula el punto X para el test
            pointY = ((pointX * distanceY) / distanceX);    // Ahora ya puedes calcular el punto Y de la trayectoria
            pathY = (ball.y + pointY);
        } else {
            distanceY = (ball.y - ballOldposY);             // Calcula la distancia sobre el eje Y
            pointX = (limitXB - ballOldposX);               // Segun la direccion de la bola, calcula el punto X para el test
            pointY = ((pointX * distanceY) / distanceX);    // Ahora ya puedes calcular el punto Y de la trayectoria
            pathY = (ballOldposY + pointY);
        }
        // Si hay colision...
        if (((pathY + ball.height) >= palaB.y) && (pathY <= (palaB.y + palaB.height))) {
            // Recoloca la bola
            ball.x = (palaB.x - ball.width);
            ball.y = pathY;
            // Invierte el sentido de la bola
            ballSpeedX = -ballSpeedX;
            // Registra la posicion de la pala e indica que a habido una colision
            palY = (palaB.y + (palaB.height / 2));
            palSize = palaB.height;
            collision = true;
        }
    }

    // Angulo de rebote Y velocidad si hay colision
    if (collision) {

        // Calcula la Y de la bola
        ballY = (ball.y + (ball.height / 2));
        maxY = (ballMaxSpeed * 1.5);
        // Si has colisionado en la zona superior...
        if (ballY < (palY - (palSize / 8))) {
            ballSpeedY = -((palY - ballY) / 4);
            if (ballSpeedY < -maxY) ballSpeedY = -maxY;
        }
        // Si has colisionado en la zona inferior...
        if (ballY > (palY + (palSize / 8))) {
            ballSpeedY = ((ballY - palY) / 4);
            if (ballSpeedY > maxY) ballSpeedY = maxY;
        }

        // Si ivas hacia la derecha
        if (ballSpeedX > 0) {
            // Aumenta la velocidad
            ballSpeedX += ballSpeedAcc;
            // Y limita el maximo
            if (ballSpeedX > ballMaxSpeed) ballSpeedX = ballMaxSpeed;
        } else {
            // Aumenta la velocidad
            ballSpeedX -= ballSpeedAcc;
            // Y limita el maximo
            if (ballSpeedX < -ballMaxSpeed) ballSpeedX = -ballMaxSpeed;
        }

    }


}


// Actualiza los marcadores de puntuacion
function UpdateScore():void {

    // Score del player
    scoreA.gotoAndStop(playerScore + 1);
    // Score de la CPU
    scoreB.gotoAndStop(cpuScore + 1);

}


// Funcion SetPoint (Mira quien ha marcado el punto)
function SetPoint(player:Boolean):void {

    // Recoloca las palas en las posiciones iniciales
    palaA.y = (300 - (palaA.height / 2));
    palaB.y = (300 - (palaB.height / 2));

    // Dependiendo de quien sea el punto...
    if (player) {
        // Si el punto es del jugador
        playerScore ++;
        // Haz que la CPU sea mas lista, reduciendo el tiempo de reaccion
        cpuSeekDistance -= 10;
        // Si ha ganado la partida...
        if (playerScore >= matchPoints) {
            playerScore = matchPoints;
            // Indica el final del juego
            gameOver = true;
            // Muestra el cartel correspondiente
            winText.alpha = 1;
        }
        // Recoloca la bola
        ball.y = (palaB.y + (palaB.height / 2) - (ball.height / 2));
        ball.x = (palaB.x - 50);
        // Reinicia la velocidad X
        ballSpeedX = -ballStartSpeed;
    } else {
        // Si el punto es de la CPU
        cpuScore ++;
        // Si ha ganado la partida...
        if (cpuScore >= matchPoints) {
            cpuScore = matchPoints;
            // Indica el final del juego
            gameOver = true;
            // Muestra el cartel correspondiente
            loseText.alpha = 1;
        }
        ball.y = (palaA.y + (palaA.height / 2) - (ball.height / 2));
        ball.x = (palaA.x + 50);
        // Reinicia la velocidad X
        ballSpeedX = ballStartSpeed;
    }

    // Guarda la posicion actual de la bola
    BackupBallPos();

    // Pausa el juego
    playGame = false;

    // Actualiza los marcadores
    UpdateScore();

    // Reinicia la velocidad Y
    ballSpeedY = ballStartSpeed;

}

// Control del mensage de Press Space Key
function PressSpaceKeyMessage():void {

    if (playGame) {
        // Si el juego esta en marcha, oculta el mensage
        spaceKey.alpha = 0;
        spaceKeyShow = false;
        spaceKeyTimer = 0;
    } else {
        // Si no, animacion del mensage de Space Key
        spaceKeyTimer ++;
        if (spaceKeyTimer >= 30) {
            spaceKeyTimer = 0;
            if (spaceKeyShow) {
                // Muestra el mensage
                spaceKey.alpha = 1;
            } else {
                // Oculta el mensage
                spaceKey.alpha = 0;
            }
            // Invierte el estado de visivilidad
            spaceKeyShow = !spaceKeyShow;
        }
    }

}


// Elimina TODOS los eventos antes de salir del frame
function PongCleanUpEvents():void {
    myTimer.removeEventListener(TimerEvent.TIMER, Update);
    stage.removeEventListener(KeyboardEvent.KEY_DOWN, KeyDown);
    stage.removeEventListener(KeyboardEvent.KEY_UP, KeyUp);
}


// Incializa los datos necesarios para que el juego funcione
function InitGame():void {
    ballMaxSpeed = palaA.width * 4; // Velocidad maxima de la pelota == ancho de la paleta
    ballSpeedX = ballStartSpeed;    // Velocidad Inicial
    ballSpeedY = ballStartSpeed;    // Velocidad Inicial
    UpdateScore();                  // Actualiza los marcadores
    BackupBallPos();                // Guarda la posicion actual de la pelota
}




/*
    Bloque del programa principal
*/

// Inicializaciones
InitGame();

// Enciende el Timer
myTimer.start();

// Deten FLASH para que no sale al siguiente frame
stop();