Source code for a Space Invaders type game [MAIN]

/*
    Space Inaveders
    (c) 2013 Cesar Rincon
    Escola Municipal d'Art i Diseny de Vilanova
*/



/*
    Imports de clases externas propias
*/
import emaid.commons.CTools;
import emaid.space.CPlayer;
import emaid.space.CEnemy;
import emaid.space.CGamePlay;
import emaid.space.CGui;
import emaid.space.CGfxEffects;
import emaid.space.CSound;

/*
    Imports de clases de Flash
*/
import flash.text.TextField;
import flash.text.TextFormat;



/*
    Variables globales
*/
var Tools:CTools = new CTools();            // Objeto de la clase CTools

var player:CPlayer = new CPlayer();         // Objeto con el Sprite del player
var enemy:CEnemy = new CEnemy();            // Objeto con el Sprite de los enemigos
var game:CGamePlay = new CGamePlay();       // Objeto con todos los datos de gestion del juego
var gui:CGui = new CGui();                  // Objeto con la GUI del juego
var gfx:CGfxEffects = new CGfxEffects();    // Objeto con los efectos graficos
var sfx:CSound = new CSound();              // Objeto con los efectos de sonido

/*
    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) <<<
    */

    // Segun el thread, ejecuta las partes de codigo adecuadas
    switch (game.thread) {

        // Espera a que se pulse espacio para iniciar la ronda
        case 0:
            // Si se presiona espacio, cambia de thread
            if (WaitForSpaceKey()) {
                // Crea la parrilla inicial de enemigos
                CreateEnemyGrid(0, 0, 4, 8);
                // Reordena los Sprites
                SortSprites();
                // Calcula la posicion de la parrilla y colocala ahi
                enemy.gridX = ((stage.stageWidth / 2) - (enemy.gridWidth / 2));
                enemy.gridY = -enemy.gridHeight;
                PlaceEnemyGrid(enemy.gridX, enemy.gridY);
                // Siguiente Thread
                game.thread = 1;
            }
            break;

        // Baja la parrilla de enemigos
        case 1:
            // Mientras la parrilla no este en su sitio...
            if (enemy.gridY < 60) {
                // Baja un poco la parrilla
                enemy.gridY += 2;
                // Posicionala
                PlaceEnemyGrid(enemy.gridX, enemy.gridY);
            } else {
                enemy.gridY = 60;                   // Ajuste de posicion
                game.playerCanShoot = true;         // El jugador puede disparar
                game.enemyCanShoot = true;          // Y los enemigos tambien
                player.inmune = false;              // El player ya no es inmune
                game.thread = 2;                    // Siguiente thread
            }
            break;

        // Ejecucion normal de la partida
        case 2:
            MoveEnemyGrid();                        // Mueve la parrilla de enemigos
            // Verifica si los quedan enemigos
            if (enemy.enemyNum == 0) {              // Si has eliminado a todos los enemigos.. prepara el cambio de ronda
                game.playerCanShoot = false;        // El jugador no puede disparar
                game.enemyCanShoot = false;         // Los enemigos tampoco
                player.inmune = true;               // El player es inmune
                game.thread = 3;                    // Salta al siguiente thread
            }
            // Verifica si el player ha muerto
            if (player.dead) {
                game.thread = 4;                    // Salta al siguiente thread
            }
            break;

        // Espera a que la pantalla este limpia de disparos y explosiones
        case 3:
            // Si ya no hay disparos ni explosiones activas...
            if (player.canShoot && (gfx.explosionNum == 0) && (enemy.shootNum == 0)) {
                // Suma una ronda
                game.round ++;
                UpdateGuiRound();
                // Crea el Mensage de espera
                CreatePressSpace();
                // Aumenta la dificultad al cambiar de ronda
                enemy.shootLack = (enemy.shootLack >> 1);
                if (enemy.shootLack < 1) enemy.shootLack = 1;
                // Vuelve al thread que genera la parrilla de enemigos
                game.thread = 0;
            }
            break;

        // El player ha muerto, espera a limpiar la escena
        case 4:
            MoveEnemyGrid();                        // Mueve la parrilla de enemigos
            // Si ya no hay disparos ni explosiones activas...
            if (player.canShoot && (gfx.explosionNum == 0) && (enemy.shootNum == 0)) {
                // Si aun le quedan vidas al player, resucitalo
                if (game.lives > 0) {
                    // Crea el Mensage de espera
                    CreatePressSpace();
                    // Salta al siguiente thread
                    game.thread = 5;
                } else {
                    // Si no, GAME OVER
                    CreateGameOver();
                    // Salta al threas de Game Over
                    game.thread = 6;
                }
            }
            break;

        // Resucita al player y espera a que se pulse espacio para continuar
        case 5:
            MoveEnemyGrid();                        // Mueve la parrilla de enemigos
            if (WaitForSpaceKey()) {
                // Colocalo en la posicion inicial
                player.sprite.x = ((stage.stageWidth / 2) - (player.playerH / 2));
                player.sprite.y = (stage.stageHeight - (player.playerV * 2));
                // Control de animacion por defecto
                player.animation = 0;
                game.playerCanShoot = true;         // El jugador puede disparar
                game.enemyCanShoot = true;          // Y los enemigos tambien
                player.inmune = false;              // El player ya no es inmune
                player.dead = false;                // Resucita al player
                game.thread = 2;                    // Siguiente thread
            }
            break;

        // Game Over
        case 6:
            MoveEnemyGrid();                        // Mueve la parrilla de enemigos
            if (WaitForSpaceKey()) {
                // Si hay enemigos en pantalla, eliminalos...
                while (enemy.enemyNum > 0) {
                    DeleteEnemyFromGrid(enemy.enemyNum - 1);
                }
                // Elimina el texto de "Game Over"
                removeChild(gui.gameOver);
                // Salta al thread de espera de reinicio (automatico)
                game.thread = 7;
            }
            break;

        // Reinicia la partida
        case 7:
            // Si no hay explosiones ni disparos activos, reinicia la partida
            if ((gfx.explosionNum == 0) && (enemy.shootNum == 0)) RestartGame();
            break;

        // Error Trap, nada por defecto
        default:
            break;

    }

    // Precesos comunes
    MovePlayer();               // Mueve al jugador
    PlayerShoot();              // Control del disparo del jugador
    EnemyShoot();               // COntrol del disparo de los enemigos
    ManageExplosions();         // Gestion de explosiones activas
    UpdateGuiScore();           // Actualiza la GUI (Score)
    ScrollBackGrounds();        // Mueve los fondos (Scroll Parallax)
    GlowCreditsText();          // Glow del texto de los creditos
    BgmControl();               // Control de la musica

}



/*
    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);
}


// Crea el Sprite de la nave del jugador
function CreatePlayer():void {

    // Crea el player
    player.sprite = new cShip();
    // Define los parametros del sprite
    player.playerH = 39;
    player.playerV = 43;
    // Manda el sprite del player al stage
    addChild(player.sprite);
    // Colocalo en la posicion inicial
    player.sprite.x = ((stage.stageWidth / 2) - (player.playerH / 2));
    player.sprite.y = (stage.stageHeight - (player.playerV * 2));
    // Control de animacion por defecto
    player.animation = 0;
    // Crea el disparo
    player.shootSprite = new cSpaceshipShoot();
    // Define los parametros del disparo
    player.shootH = 21;
    player.shootV = 21;
    // Mandalo al stage
    addChild(player.shootSprite);
    // Escondelo fuera del stage
    player.shootSprite.x = -player.shootH;
    player.shootSprite.y = -player.shootV;
    player.shootSprite.gotoAndStop(1);
    // Valores por defecto de los flags
    player.canShoot = true;             // Disparo listo
    player.dead = false;                // Por defecto, no te mates nada mas aparecer
    player.inmune = true;               // Al aparecer es invulnerable
    game.playerCanShoot = false;        // El jugador no puede disparar

}


// Mueve al Player
function MovePlayer():void {
    // Si presionas Izquierda...
    if (Tools.kLeft && !Tools.kRight) {
        // Muevete
        player.sprite.x -= player.moveSpeed;
        if (player.sprite.x < 0) player.sprite.x = 0;
        // Cambia el frame de animacion si es necesario
        if (player.animation != 1) {
            player.sprite.gotoAndPlay(11);
            player.animation = 1;
        }
    }
    // Si presionas Derecha...
    if (Tools.kRight && !Tools.kLeft) {
        // Muevete
        player.sprite.x += player.moveSpeed;
        if (player.sprite.x > (stage.stageWidth - player.playerH)) player.sprite.x = (stage.stageWidth - player.playerH);
        // Cambia el frame de animacion si es necesario
        if (player.animation != 2) {
            player.sprite.gotoAndPlay(21);
            player.animation = 2;
        }
    }
    // Si no se presiona ni derecha ni izquierda, restaura la animacion
    if (!Tools.kRight && !Tools.kLeft && (player.animation != 0)) {
        player.sprite.gotoAndPlay(1);
        player.animation = 0;
    }
    // Segun el estado del player
    if (player.inmune) {
        // Efecto inmunidad
        player.sprite.visible = !player.sprite.visible;
    } else if (!player.dead) {
        // Estado normal
        player.sprite.visible = true;
    } else {
        // Estas muerto, macho
        player.sprite.visible = false;          // Me ocultas
        player.sprite.x = -player.playerH;      // Y me mandas fuera del Stage
        player.sprite.y = -player.playerV;
    }
}


// Funcion de disparo
function PlayerShoot():void {
    // Variables locales
    var i:Number = 0;
    // Si se puede presionar "ESPACIO" para disparar...
    // Eso es, el Player no esta disparando, esta habilitado su disparo, no esta muerto y se ha presionado ESPACIO
    if (player.canShoot && game.playerCanShoot && !player.dead && Tools.kSpace) {
        // Inicializa el disparo
        player.shootSprite.gotoAndPlay(5);
        player.shootSprite.x = (player.sprite.x  + (player.playerH / 2) - (player.shootH / 2));
        player.shootSprite.y = (player.sprite.y  - player.shootV);
        player.canShoot = false;
        // Sonido del disparo ***
        sfx.PlaySound(sfx.playerShoot, CSound.playerShootVol);
    }
    // Si el disparo esta en proceso
    if (!player.canShoot) {
        // Mueve el disparo
        player.shootSprite.y -= player.shootSpeed;
        // Limite del escenario
        if (player.shootSprite.y < -player.shootV) {
            // Recolocalo
            player.shootSprite.y = -player.shootH;
            player.shootSprite.x = -player.shootV;
            // Para la animacion
            player.shootSprite.gotoAndStop(1);
            // Rehabilita del disparo
            player.canShoot = true;
        }
        // Si has tocado algun enemigo...
        for (i = 0; i < enemy.enemyNum; i ++) {
            if (Tools.BoxCollision(player.shootSprite.x, player.shootSprite.y, player.shootH, player.shootV, enemy.sprite[i].x, enemy.sprite[i].y, enemy.enemyH[i], enemy.enemyV[i])) {
                // Suma la puntuacion obtenida
                game.score += enemy.score[i];
                // Mata al enemigo
                DeleteEnemyFromGrid(i);
                // Recoloca el disparo
                player.shootSprite.y = -player.shootH;
                player.shootSprite.x = -player.shootV;
                // Para la animacion
                player.shootSprite.gotoAndStop(1);
                // Rehabilita del disparo
                player.canShoot = true;
            }
        }
    }
}


// Funcion para matar al player
function KillPlayer():void {

    // Variables
    var posX:Number, posY:Number;

    // Genera una explosion en la posicion del player
    posX = (player.sprite.x + (player.playerH / 2));    // Calcula la posicion
    posY = (player.sprite.y + (player.playerV / 2));
    sfx.PlaySound(sfx.playerExplosion, CSound.playerExplosionVol);      // Sonido de la explosion
    MakeExplosion(posX, posY);                                          // Genera una explosion en la posicion del player

    // Quita una vida al player
    game.lives --;
    if (game.lives < 0) game.lives = 0;     // Debug (Las vidas no seran menor a 0)
    // Actualiza el marcador
    UpdateGuiLives();

    game.playerCanShoot = false;        // El jugador no puede disparar
    game.enemyCanShoot = false;         // Los enemigos tampoco

    // Marca al jugador como muerto
    player.dead = true;

}


// Crea una parrilla de enemigos
function CreateEnemyGrid(posX:Number, posY:Number, rows:Number, columns:Number):void {

    // Variables privadas
    var iX:Number, iY:Number;       // Control del indcie de creacion de enemigos
    var i:Number;

    // Inicializa las variables
    enemy.enemyNum = 0;

    // Bucles de creacion
    for (iY = 0; iY < rows; iY ++) {
        for (iX = 0; iX < columns; iX ++) {
            // Crea la instancia del enemigo en pantalla
            enemy.sprite[enemy.enemyNum] = new cUfo();
            // Parametros del enemigo
            enemy.enemyH[enemy.enemyNum] = 53;      // Tamaño del grafico
            enemy.enemyV[enemy.enemyNum] = 31;
            enemy.enemyX[enemy.enemyNum] = iX;      // Posicion en la parrilla
            enemy.enemyY[enemy.enemyNum] = iY;
            // Mandalo al Stage haciendolo parent suyo
            addChild(enemy.sprite[enemy.enemyNum]);
            // Recoloca el enemigo en pantalla
            enemy.sprite[enemy.enemyNum].x = posX + (iX * (enemy.enemyH[enemy.enemyNum] + (enemy.enemyH[enemy.enemyNum] / 8)));
            enemy.sprite[enemy.enemyNum].y = posY + (iY * (enemy.enemyV[enemy.enemyNum] + (enemy.enemyV[enemy.enemyNum] / 8)));
            // Asigna la puntuacion que dara el enemigo al morir
            enemy.score[enemy.enemyNum] = 10;
            // Incrementa el contador de enemigos
            enemy.enemyNum ++;
        }
    }

    // Guarda los datos del GRID (usa como base la info del primer enemigo)
    enemy.gridX = posX;
    enemy.gridY = posY;
    enemy.rows = rows;
    enemy.columns = columns;
    enemy.gridWidth = ((columns * (enemy.enemyH[0] + (enemy.enemyH[0] / 8))) - (enemy.enemyH[0] / 8));
    enemy.gridHeight = ((rows * (enemy.enemyV[0] + (enemy.enemyV[0] / 8))) - (enemy.enemyV[0] / 8));

    // Iniciliza los datos de disparo de los enemigos
    enemy.shootNum = 0;             // Numero de disparos activos de los enemigos
    enemy.shootTimer = 0;           // Temporizador de disparo
    game.enemyCanShoot = false;     // Aun no pueden disparar

}


// Funcion para posicionar la parrilla de enemigos
function PlaceEnemyGrid(pX:Number, pY:Number) {

    // Variables privadas
    var i:Number = 0;               // Contador de indice de los arrays

    // Asigna la nueva posicion
    enemy.gridX = pX;
    enemy.gridY = pY;

    // Bucles de dibujado
    for (i = 0; i < enemy.enemyNum; i ++) {
        // Recoloca el enemigo en pantalla
        enemy.sprite[i].x = enemy.gridX + (enemy.enemyX[i] * (enemy.enemyH[i] + (enemy.enemyH[i] / 8)));
        enemy.sprite[i].y = enemy.gridY + (enemy.enemyY[i] * (enemy.enemyV[i] + (enemy.enemyV[i] / 8)));
    }

}



// Funcion para mover la parrilla de enemigos
function MoveEnemyGrid():void {

    // Variables privadas
    var i:Number = 0;               // Contador de indice de los arrays

    // Calculo de la nueva posicion de la parrilla
    enemy.gridX += enemy.enemySpeed;
    // Limite derecho
    if ((enemy.gridX + enemy.gridWidth) > stage.stageWidth) {
        enemy.gridX = (stage.stageWidth - enemy.gridWidth);
        enemy.enemySpeed = -enemy.enemySpeed;
    }
    // Limite izquierdo
    if (enemy.gridX < 0) {
        enemy.gridX = 0;
        enemy.enemySpeed = -enemy.enemySpeed;
    }

    // Bucles de movimiento
    for (i = 0; i < enemy.enemyNum; i ++) {
        // Recoloca el enemigo en pantalla
        enemy.sprite[i].x = enemy.gridX + (enemy.enemyX[i] * (enemy.enemyH[i] + (enemy.enemyH[i] / 8)));
        enemy.sprite[i].y = enemy.gridY + (enemy.enemyY[i] * (enemy.enemyV[i] + (enemy.enemyV[i] / 8)));
    }

}


// Elimina un enemigo del stage
function DeleteEnemyFromGrid(i:Number):void {

    // Variables
    var posX:Number = (enemy.sprite[i].x + (enemy.enemyH[i] / 2));  // Guarda la posicion actual del Sprite (X)
    var posY:Number = (enemy.sprite[i].y + (enemy.enemyV[i] / 2));  // Guarda la posicion actual del Sprite (Y)

    // Elimina el enemigo del stage junto a todos sus datos
    removeChild(enemy.sprite[i]);   // Quitalo del Stage
    enemy.sprite.splice(i, 1);      // Elimina ese enemigo de los Arrays
    enemy.enemyH.splice(i, 1);
    enemy.enemyV.splice(i, 1);
    enemy.enemyX.splice(i, 1);
    enemy.enemyY.splice(i, 1);
    enemy.score.splice(i, 1);
    enemy.enemyNum --;              // Quita un enemigo del contador

    // Para terminar, instancia una explosion en la posicion donde estava el enemigo, junto con el sonido de la misma
    sfx.PlaySound(sfx.ufoExplosion, CSound.ufoExplosionVol);        // Sonido de la explosion
    MakeExplosion(posX, posY);                                      // Instancia la explosion

}


// Gestiona la rutina de disparo aleatorio de los enemigos
function EnemyShoot():void {

    // Variables locales
    var i:Number;
    var remove:Boolean;

    // Si hay enemigos activos y esta habilitado su disparo, ademas, el player esta vivo...
    if ((enemy.enemyNum > 0) && game.enemyCanShoot && !player.dead) {
        // Actualiza el timer
        enemy.shootTimer ++;
        // Si hay que realizar un nuevo disparo...
        if (enemy.shootTimer > enemy.shootLack) {
            // Resetea el timer
            enemy.shootTimer = 0;
            // Decide que enemigo realiza el disparo
            i = Tools.RandomRange(0, enemy.enemyNum);
            // Crea la instancia del enemigo en pantalla
            enemy.shootSprite[enemy.shootNum] = new cUfoShoot();
            // Parametros del disparo
            enemy.shootH[enemy.shootNum] = 21;
            enemy.shootV[enemy.shootNum] = 21;
            // Mandalo al Stage haciendolo parent suyo
            addChild(enemy.shootSprite[enemy.shootNum]);
            // Posicionalo en las coordenadas del enemigo que lo ha disparado
            enemy.shootSprite[enemy.shootNum].x = ((enemy.sprite[i].x + (enemy.enemyH[i] / 2)) - (enemy.shootH[enemy.shootNum] / 2));
            enemy.shootSprite[enemy.shootNum].y = (enemy.sprite[i].y + (enemy.enemyV[i] / 2));
            // Actualiza en contador de disparos activos
            enemy.shootNum ++;
            // *** Reordena las prioridades de los Sprites en pantalla ***
            SortSprites();
            // Sonido del disparo ***
            sfx.PlaySound(sfx.ufoShoot, CSound.ufoShootVol);
        }
    }

    // Si hay algun disparo activo...
    if (enemy.shootNum > 0) {
        // Flag arriba para la primera ejecucion
        remove = true;
        // Repite mientras queden objetivos a eliminar
        while (remove) {
            // Flag abajo al entrar al bucle...
            remove = false;
            // Mira todos los disparos activos
            for (i = 0; i < enemy.shootNum; i ++) {
                // Muevelo...
                enemy.shootSprite[i].y += enemy.shootSpeed;
                // Si sales el Stage, destruyelo
                if (enemy.shootSprite[i].y > stage.stageHeight) {
                    // Marca este disparo para ser eliminado
                    remove = true;
                // Si le das al player...
                } else if (Tools.BoxCollision(enemy.shootSprite[i].x, enemy.shootSprite[i].y, enemy.shootH[i], enemy.shootV[i], player.sprite.x, player.sprite.y, player.playerH, player.playerV)) {
                    // Marca este disparo para ser eliminado
                    remove = true;
                    // Mata la player si no es inmune
                    if (!player.inmune) KillPlayer();
                }
                // Si hay que eliminar a este disparo...
                if (remove) {
                    // Quita el objeto del stage
                    removeChild(enemy.shootSprite[i]);
                    // Elimina este disparo de los arrays
                    enemy.shootSprite.splice(i, 1);
                    enemy.shootH.splice(i, 1);
                    enemy.shootV.splice(i, 1);
                    // Registra que hay un disparo menos
                    enemy.shootNum --;
                    // Sal YA
                    break;
                }
            }
        }
    }

}



// Function de inicializacion de los fondos
function ResetBackgrounds():void {

    // Posicion el fondo en su posicion original
    bgElectricField.x = 0;
    bgElectricField.y = -168;
    bgDeepSpace.x = 0;
    bgDeepSpace.y = -512;

}



// Funcion para mover el fondo
function ScrollBackGrounds():void {

    // Mueve el fondo
    bgElectricField.y += 2;
    if (bgElectricField.y > 0) bgElectricField.y -= 168;

    // Mueve el fondo
    bgDeepSpace.y += 1;
    if (bgDeepSpace.y > 0) bgDeepSpace.y -= 512;

}

// Funcion de control del Glow de los textos
function GlowCreditsText():void {

    // Calcula el nuevo valor del glow
    gfx.creditsGlowLevel ++;
    if (gfx.creditsGlowLevel > 50) gfx.creditsGlowLevel = 0;
    var alphaLevel:Number = ((50 - gfx.creditsGlowLevel) / 50);
    var scale:Number = (gfx.creditsGlowLevel / 2);

    // Cambia el filtro
    gfx.CreditsGlow.alpha = alphaLevel;
    gfx.CreditsGlow.blurX = (scale + 1);
    gfx.CreditsGlow.blurY = (scale + 1);

    // Aplica el filtro al texto
    gui.copyright.filters = [gfx.CreditsGlow];

}


// Crea la GUI
function CreateGui():void {

    // Marcador de Score
    gui.score.x = 10;
    gui.score.y = 10;
    gui.score.autoSize = "left";
    gui.score.text = "SCORE " + game.score;
    gui.score.setTextFormat(gui.style);             // Dale formato al texto

    // Marcador de rondas
    gui.round.x = 320;
    gui.round.y = 10;
    gui.round.autoSize = "left";
    gui.round.text = "ROUND " + game.round;
    gui.round.setTextFormat(gui.style);             // Dale formato al texto

    // Marcador de rondas
    gui.lives.x = 680;
    gui.lives.y = 10;
    gui.lives.autoSize = "left";
    gui.lives.text = "LIVES " + game.lives;
    gui.lives.setTextFormat(gui.style);             // Dale formato al texto


    // Manda los TextFiled al stage
    addChild(gui.score);
    addChild(gui.round);
    addChild(gui.lives);
    // Aplicale los filtros
    gui.score.filters = [gfx.GuiTextGlow];
    gui.round.filters = [gfx.GuiTextGlow];
    gui.lives.filters = [gfx.GuiTextGlow];


    // Textos de copyright
    gui.copyright.text = "(cc) 2013 Cesar Rincon / EMAID - Escola municipal d'art i diseny de Vilanova."
    gui.copyright.autoSize = "left";
    gui.copyright.setTextFormat(gui.miniStyle);             // Dale formato al texto
    gui.copyright.x = ((stage.stageWidth >> 1) - (gui.copyright.width >> 1));
    gui.copyright.y = (stage.stageHeight - gui.copyright.height);
    addChild(gui.copyright);
    gui.copyright.filters = [gfx.CreditsGlow];

}


// Actualiza el Gui Score
function UpdateGuiScore():void {

    // Si la puntuacion del player no es la misma que la mostrada...
    if (game.guiScore < game.score) {
        // Actualiza la puntuacion
        game.guiScore ++;
        gui.score.text = "SCORE " + game.guiScore;
        gui.score.setTextFormat(gui.style);
    }

}


// Actualiza el Gui Rounds
function UpdateGuiRound():void {
    // Actualiza el marcador de rondas
    gui.round.text = "ROUND " + game.round;
    gui.round.setTextFormat(gui.style);             // Dale formato al texto
}


// Actualiza el Gui Score
function UpdateGuiLives():void {
    // Actualiza el marcador de vidas
    gui.lives.text = "LIVES " + game.lives;
    gui.lives.setTextFormat(gui.style);
}


// Crea el mensage "Press Space"
function CreatePressSpace():void {

    // Crea el Texto
    gui.pressSpace.autoSize = "left";           // Parametros del texto
    gui.pressSpace.text = "PRESS SPACE";
    gui.pressSpace.setTextFormat(gui.bigStyle); // Dale formato al texto
    addChild(gui.pressSpace);                   // Mandalo al stage
    gui.pressSpace.x = ((stage.stageWidth / 2) - (gui.pressSpace.width / 2));   // Posicionalo en el centro del stage
    gui.pressSpace.y = ((stage.stageHeight / 2) - (gui.pressSpace.height / 2));
    gui.pressSpace.filters = [gfx.BigTextGlow];
    gui.pressSpace.visible = false;     // Texto oculto por defecto

    // Variables de control
    game.pressSpaceShow = false;
    game.pressSpaceTimer = 0;

    // Voz del evento ***
    sfx.PlaySound(sfx.startVoice, CSound.voiceVol);

}


// Crea el mensage "Game Over"
function CreateGameOver():void {

    // Crea el Texto "Game Over"
    gui.gameOver.autoSize = "left";             // Parametros del texto
    gui.gameOver.text = "GAME OVER";
    gui.gameOver.setTextFormat(gui.bigStyle);   // Dale formato al texto
    addChild(gui.gameOver);                     // Mandalo al stage
    gui.gameOver.x = ((stage.stageWidth / 2) - (gui.gameOver.width / 2));   // Posicionalo en el centro del stage
    gui.gameOver.y = ((stage.stageHeight / 2) - gui.gameOver.height);
    gui.gameOver.filters = [gfx.BigTextGlow];

    // Crea el Texto "Press Space"
    gui.pressSpace.autoSize = "left";           // Parametros del texto
    gui.pressSpace.text = "PRESS SPACE";
    gui.pressSpace.setTextFormat(gui.style);    // Dale formato al texto
    addChild(gui.pressSpace);                   // Mandalo al stage
    gui.pressSpace.x = ((stage.stageWidth / 2) - (gui.pressSpace.width / 2));   // Posicionalo en el centro del stage
    gui.pressSpace.y = ((stage.stageHeight / 2) + gui.pressSpace.height);
    gui.pressSpace.filters = [gfx.BigTextGlow];
    gui.pressSpace.visible = false;             // Texto oculto por defecto

    // Variables de control
    game.pressSpaceShow = false;
    game.pressSpaceTimer = 0;

    // Voz del evento ***
    sfx.PlaySound(sfx.gameOver, CSound.voiceVol);

}


// Gestion del mensage de "Press Space"
function WaitForSpaceKey():Boolean {

    // Variables
    var r:Boolean = false;  // Guarda si se ha presionado o no la tecla espacio

    // Gestion de la visibilidad del texto
    game.pressSpaceTimer ++;
    if (game.pressSpaceTimer > 15) {
        game.pressSpaceTimer = 0;
        game.pressSpaceShow = !game.pressSpaceShow;
        gui.pressSpace.visible = game.pressSpaceShow;
    }

    // Si se presiona espacio, elimina el objeto y reinicia las variables de control
    if (Tools.kSpace) {
        removeChild(gui.pressSpace);        // Elimina el texto del stage
        game.pressSpaceShow = false;        // Reinicia las variables de control
        game.pressSpaceTimer = 0;
        r = true;                           // Indica que se ha presionado espacio
        Tools.kSpace = false;               // Resetea la pulsacio de la tecla espacio
    }

    // Devuelve el resultado
    return r;

}


// Crea los efectos graficos necesarios
function CreateGfxEffects():void {

    // Explosion
    gfx.explosionW = 48;            // Ancho de la explosion (grafico)
    gfx.explosionH = 48;            // Alto
    gfx.explosionNum = 0;           // Contador de explosiones a 0
    gfx.explosionLastFrame = 28;    // Ultimo frame "valido" de la animacion

}


// Crea una explosion en la ubicacion indicada
function MakeExplosion(posX:Number, posY:Number) {

    // Crea una nueva instancia para la explosion
    gfx.explosionSprite[gfx.explosionNum] = new cExplosion();
    // Manda la instancia a la pantalla
    addChild(gfx.explosionSprite[gfx.explosionNum]);
    // Posicionala en las coordenadas indicadas
    gfx.explosionSprite[gfx.explosionNum].x = (posX - (gfx.explosionW / 2));
    gfx.explosionSprite[gfx.explosionNum].y = (posY - (gfx.explosionH / 2));
    // *** Reordena las prioridades de los Sprites en pantalla ***
    SortSprites();
    // Incrementa el contador de explosiones
    gfx.explosionNum ++;

}


// Gestiona las explosiones activas en el stage
function ManageExplosions():void {

    // Variables
    var i:Number = 0;   // Indice
    var retry = true;   // Flag de reintentos de eliminacion

    // Si hay alguna explosion activa en el stage
    if (gfx.explosionNum > 0) {
        // Si hay que seguir analizando explosiones...
        while (retry) {
            // Una vez has entrado en el bucle, flag abajo
            retry = false;
            // Mira si hay que eliminar alguna explosion
            for (i = 0; i < gfx.explosionNum; i ++) {
                // Si ya has llegado al ultimo frame de la animacion, elimina esta instancia
                if (gfx.explosionSprite[i].currentFrame > gfx.explosionLastFrame) {
                    // Elimina la instancia de esta explosion
                    removeChild(gfx.explosionSprite[i]);
                    // Borra los datos de la misma de los arrays
                    gfx.explosionSprite.splice(i, 1);
                    // Actualiza el contador
                    gfx.explosionNum --;
                    // Flag de reintento arriba
                    retry = true;
                    // Fuerza la salida de este bucle
                    break;
                }
            }
        }
    }

}


// Funcion para ordenar los sprites en las prioridades correspondientes
function SortSprites():void {

    // Variables
    var i:Number;

    // Si existen, reordena los enemigos
    if (enemy.enemyNum > 0) {
        for (i = 0; i < enemy.enemyNum; i ++) {
            setChildIndex(enemy.sprite[i], (numChildren - 1));
        }
    }

    // Ahora la nave del jugador y su disparo
    setChildIndex(player.shootSprite, (numChildren - 1));
    setChildIndex(player.sprite, (numChildren - 1));

    // Para terminar, los marcadores siempre estan visibles por encima del resto de elementos
    setChildIndex(gui.score, (numChildren - 1));
    setChildIndex(gui.round, (numChildren - 1));
    setChildIndex(gui.lives, (numChildren - 1));
    setChildIndex(gui.copyright, (numChildren - 1));

}


// Prepara los efectos de sonido
function LoadSfx():void {

    // Carga en memoria desde la biblioteca los efectos de sonido
    sfx.playerShoot = new sPlayerShoot();           // Disparo del player
    sfx.playerExplosion = new sPlayerExplosion();   // Explosion del Player
    sfx.ufoShoot = new sUfoShoot();                 // Disparo del Enemigo
    sfx.ufoExplosion = new sUfoExplosion();         // Explosion del Enemigo
    sfx.startVoice = new sStartVoice();             // Voz de Game Start
    sfx.gameOver = new sGameOver();                 // Voz de Game Over

    // Carga las musicas
    sfx.bgm = new mMainTheme();

}


// Funcion para el Loop de la Musica
function BgmControl():void {

    // Si la musica ha llegado al final
    if (sfx.bgmChannel.position >= sfx.bgm.length) {
        // Asegurate de detener este canal
        sfx.bgmChannel.stop();
        // Reproduce de nuevo la musica
        sfx.bgmChannel = sfx.PlayBgm(sfx.bgm, CSound.bgmVol);
    }

}



/*
    Inicializaciones
*/

// Primera Inicializacion del Juego
function InitGame():void {

    CreatePlayer();                     // Crea al jugador
    CreateGfxEffects();                 // Inicializa los efectos graficos
    LoadSfx();                          // Carga nos efectos de sonido en RAM
    ResetBackgrounds();                 // Reposiciona los fondos

    // Inicializa los demas datos de la partida
    game.score = 0;         // Puntuacion del jugador a 0
    game.guiScore = 0;
    game.lives = 3;         // nº de vidas iniciales
    game.round = 1;         // nº de ronda inicial
    game.thread = 0;        // Hilo inicial para la maquina de estados
    enemy.shootLack = 30;   // Carencia entre disparos

    CreateGui();            // Crea la interfaz grafica del usuario
    CreatePressSpace();     // Muestra el mensage de "Press Space"

    sfx.bgmChannel = sfx.PlayBgm(sfx.bgm, CSound.bgmVol);   // Musica de fondo

    myTimer.start();                        // Enciende el timer del juego

}


// Reinicia la partida
function RestartGame():void {

    // Deten el Timer mientras dura el reinicio
    myTimer.stop();

    // Inicializa los demas datos de la partida
    game.score = 0;         // Puntuacion del jugador a 0
    game.guiScore = -1;     // Trick para forzar la actualizacion del Score
    game.lives = 3;         // nº de vidas iniciales
    game.round = 1;         // nº de ronda inicial
    game.thread = 0;        // Hilo inicial para la maquina de estados
    enemy.shootLack = 30;   // Carencia entre disparos

    // Inicializa los flags de control
    game.playerCanShoot = false;        // El jugador no puede disparar
    game.enemyCanShoot = false;         // Los enemigos tampoco
    player.inmune = true;               // El player es inmune
    player.dead = false;                // El player no esta muerto

    // Colocalo en la posicion inicial
    player.sprite.x = ((stage.stageWidth / 2) - (player.playerH / 2));
    player.sprite.y = (stage.stageHeight - (player.playerV * 2));
    // Control de animacion por defecto
    player.animation = 0;

    // Actualiza todos los marcadores
    UpdateGuiScore();
    UpdateGuiRound();
    UpdateGuiLives();

    // Reordena todos los objetos del juego
    SortSprites();

    // Crea el Mensage de espera
    CreatePressSpace();

    // Reinicia el Timer
    myTimer.start();

}



/*
    Clean up del frame
*/

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



/*
    Programa principal
*/

InitGame();         // Inicializa el juego
stop();