videojuegos

package runmaurorun;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Rectangle;
import java.awt.Toolkit;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.WindowEvent;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.ImageIcon;
import javax.swing.JPanel;

/**
 * Board
 *
 * Modela la definición de todos los objetos de tipo <code>Map</code>.
 *
 * @author Fabián Montemayor A01280156, Mauro Amarante A01191903,
 *         Patricio Sánchez A01191893 & David Benítez A01191731
 * @version 2.0
 * @date 8/04/2015
 */


public class Board extends JPanel implements Runnable, KeyListener, MouseListener{
    //variables de medidaas del JPanel
    private final int iWidth = 1280;               //define ancho del JPanel
    private final int iHeight = 739;              //define altura del JPanel
    private final int iHeightMauro = 32;
    private final int iWidthMauro = 18;

    private int iLevel;             //define nivel actual en el juego
    private int iPosX;              //define la ubicacion de un objeto en X
    private int iPosY;              //define la ubicacion de un objeto en Y
    private int iVelocityMauro;     //define la velocidad de Mauro
    private int iDirectionMauro;        //define la direccion de Mauro
    private int iDoorOpenKey;
    private int iMouseX;    // posicion x del mouse
    private int iMouseY;    // posicion y del mouse

    private long lImmuneTimeMauro;     //define el tiempo que Mauro es immune

    private long lTime;           //tiempo restante en el juego
    private long lAnimationTime;  //tiempo animacion

    private boolean bTime;           //define si tiempo del juego ha terminado
    private boolean bEndGame = false;   // boleana de si termian el juego o no
    private boolean bPlay = false;  // boleana de si esta jugando o no

    private int iMenu = 3;  // variable del menú correspondiente
    private MenuBoton mbtBack;  // botón de Back
    private MenuBoton mbtAbout; // botón de About
    private MenuBoton mbtPlay;  // botón de Play
    private MenuBoton mbtInstruc;   // botón de instrucciones
    private MenuBoton mbtOptions;   // botón de opciones
    private MenuBoton mbtScores;    // botón de puntajes
    private MenuBoton mbtExit;  // botón de salida
    private MenuBoton mbtGameOverMenu;  //boton al menu cuando se pierde

    private Mauro mauMauro;         //objeto para Mauro
    private Terreno terMap;     //objeto para Terreno

    private ArrayList arlEnemies;   //lista de enemigos
    private ArrayList arlMapObjectsLevel1;   //lista de terrenos del nivel 1
    private ArrayList arlItems;      //lista de items

    //private Graphics graCircleReveal;

    private Thread thread;      //variable para el thread del JPanel

    //variables de control de tiempo para animacion
    private long lCurrentTime; // tiempo actual
    private long lInicialTime;    // tiempo inicial
    private long lElapsedTime;   //tiempo transcurrido

    //variables para controlar la barra de tiempo
    private long lBarraInicial; //Tiempo en donde se empieza a contar la barra
    private long lBarraActual; //Tiempo actual
    private int iBarraElapsed; //tiempo transcurrido
    private int iTiempoLimite; //tiempo limite del nivel en segundos

    //variables para controlar el powerup del foco
    private boolean bFocoOn; //Si esta prendido
    private long lFocoInicial; //Segundo donde se agarra
    private int iFocoElapsed; //Cuantos secs han pasado
    private int iFocoLimite; //Cantidad de segundos del powerup

    private boolean bRelojOn; //Si se agarró un reloj
    private boolean bGameOver;

    //variables para distancia del circulo
    private int iDist1;
    private int iDist2;

    //variables para musica
    private SoundClip sndSonidoFondo1; //Objeto sonido de fondo nivel 1


    /**
     * Board
     *
     * Metodo sobrescrito de la clase <code>JPanel</code>.<P>
     * En este metodo se inizializan las variables o se crean los objetos
     * a usarse en el <code>JPanel</code> y se definen funcionalidades.
     *
     */
    public Board() {
         /* se le añade la opcio n al JFrame de ser escuchado por los eventos
           del teclado y mouse*/
        addKeyListener(this);

        addMouseListener(this);

        //define en cual panel definir enfoque
        setFocusable(true);

        //iniciar juego
        GameInit();
        setDoubleBuffered(true);
    }

    /**
      * GameInit
      *
      * Metodo que inicializa el juego.
      *
      */
    public void GameInit() {
        //Nivel de inicio, animacion inical
        iLevel = 0;

        bGameOver = false;

        // Inicializa botones del menu
        ImageIcon imiImagen = new ImageIcon(this.getClass().getResource("Menus/bot_back.png"));
        mbtBack = new MenuBoton(imiImagen.getImage(), 1280 - imiImagen.getIconWidth(), 30, imiImagen.getIconWidth(), imiImagen.getIconHeight(), false);
        imiImagen = new ImageIcon(this.getClass().getResource("Menus/bot_acerca.png"));
        mbtAbout = new MenuBoton(imiImagen.getImage(), 1280/2 - imiImagen.getIconWidth()/2, 420, imiImagen.getIconWidth(), imiImagen.getIconHeight(), false);
        imiImagen = new ImageIcon(this.getClass().getResource("Menus/bot_instrucciones.png"));
        mbtInstruc = new MenuBoton(imiImagen.getImage(), 1280/2 - imiImagen.getIconWidth()/2, 330, imiImagen.getIconWidth(), imiImagen.getIconHeight(), false);
        imiImagen = new ImageIcon(this.getClass().getResource("Menus/bot_opciones.png"));
        mbtOptions = new MenuBoton(imiImagen.getImage(), 1280/2 - imiImagen.getIconWidth()/2, 360, imiImagen.getIconWidth(), imiImagen.getIconHeight(), false);
        imiImagen = new ImageIcon(this.getClass().getResource("Menus/bot_jugar.png"));
        mbtPlay = new MenuBoton(imiImagen.getImage(), 1280/2 - imiImagen.getIconWidth()/2, 300, imiImagen.getIconWidth(), imiImagen.getIconHeight(), false);
        imiImagen = new ImageIcon(this.getClass().getResource("Menus/bot_puntos.png"));
        mbtScores = new MenuBoton(imiImagen.getImage(), 1280/2 - imiImagen.getIconWidth()/2, 390, imiImagen.getIconWidth(), imiImagen.getIconHeight(), false);
        imiImagen = new ImageIcon(this.getClass().getResource("Menus/bot_salir.png"));
        mbtExit = new MenuBoton(imiImagen.getImage(), 1280/2 - imiImagen.getIconWidth()/2, 450, imiImagen.getIconWidth(), imiImagen.getIconHeight(), false);
        imiImagen = new ImageIcon(this.getClass().getResource("Menus/boton_menu.png"));
        mbtGameOverMenu = new MenuBoton(imiImagen.getImage(), 1280/2 - imiImagen.getIconWidth()/2, 450, imiImagen.getIconWidth(), imiImagen.getIconHeight(), false);

        //incializar a Mauro
        iVelocityMauro = 2;
        iDirectionMauro = 0;
        lImmuneTimeMauro = 0;
        String sMauro = "Animacion/Mauro/mauro1.png";
        ImageIcon imiImage = new ImageIcon(this.getClass().getResource(
                                                        sMauro));
        mauMauro = new Mauro(70, 640, iVelocityMauro, iDirectionMauro, iWidthMauro, iHeightMauro, imiImage.getImage(), 0, 0, lImmuneTimeMauro);

        //Inicializa todos los mapas
        try {
            GameInitMaps();
        } catch (IOException ex) {
            Logger.getLogger(Board.class.getName()).log(Level.SEVERE, null, ex);
        }

        // inicializa el thread
        if (thread == null || !bEndGame) {
            thread = new Thread(this);
            thread.start();
        }
    }

    /**
      * GameInitMaps
      *
      * Metodo que inicializa los mapas del juego.
      *
      */
    private void GameInitMaps() throws IOException {
        //variables
        String sLevel1WallVertical = "Terrenos/paredVerticalNivel1.jpg";
        String sLevel1WallHorizontal = "Terrenos/paredHorizontalNivel1.png";
        String sLevel1Trap = "Terrenos/picos0.png";
        String sLevel1DoorVertical = "Terrenos/puertaVerticalNivel1.png";
        String sLevel1DoorHorizontal = "Terrenos/puertaHorizontalNivel1.png";
        String sLevel1Finish = "Terrenos/meta_nivel1.png";
        String sLevel1Text = "src/runmaurorun/Terrenos/paredHorizontal.txt";

        //crea una nueva lista de terrenos
        arlMapObjectsLevel1 = new ArrayList();

        String sDato;       //string que almacena lectura de texto
        char cCharacter;     //variable que permite revisar primer caracter
        char cObjectType = 'a';

        int iWidthObject;   //variable apra ancho del objeto
        int iHeightObject;  //variable para altura del objeto
        int iDoorKey;       //varaible para control de acceso de puertas

        boolean bFinishFileRead; //variable que define si se termino la lectura

        ImageIcon imiImage;     //imagen utilizada para crear mapas

        //buscar y leer archivo de Nivel 1
        BufferedReader fileIn;

        //------------------NIVEL 1-----------------------------------------
        try {
            fileIn = new BufferedReader(new FileReader(sLevel1Text));
    	} catch (FileNotFoundException e){
            System.out.println("FILE NOT FOUND!");
            fileIn = new BufferedReader(new FileReader(
                                               sLevel1Text));
    	}

        bFinishFileRead = false;
        iWidthObject = 0;
        iHeightObject = 0;
        imiImage = new ImageIcon(this.getClass().getResource(
                                                        sLevel1WallHorizontal));

        do {
            sDato = fileIn.readLine();
            cCharacter = sDato.charAt(0);
            //definir medidas e imagen a utilizar dependiendo del objeto
            switch (cCharacter) {
              case 'a': //paredes horizontal
                    cObjectType = cCharacter;
                    iWidthObject = 76;
                    iHeightObject = 19;
                    imiImage = new ImageIcon(this.getClass().getResource(
                                                        sLevel1WallHorizontal));
                  break;
              case 'b':  //paredes vertical
                    cObjectType = cCharacter;
                    iWidthObject = 19;
                    iHeightObject = 76;
                    imiImage = new ImageIcon(this.getClass().getResource(
                                                         sLevel1WallVertical));
                  break;
              case 'c': //trampas
                    cObjectType = cCharacter;
                    iWidthObject = 32;
                    iHeightObject = 19;
                    imiImage = new ImageIcon(this.getClass().getResource(
                                                                  sLevel1Trap));
                  break;
              case 'd': //puerta horizaontal
                    cObjectType = cCharacter;
                    iWidthObject = 92;
                    iHeightObject = 8;
                  break;
              case 'e': //puerta vertical
                    cObjectType = cCharacter;
                    iWidthObject = 8;
                    iHeightObject = 90;
                  break;
              case 'f': //boton
                    cObjectType = cCharacter;
                    iWidthObject = 32;
                    iHeightObject = 19;
                  break;
              case 'g': //powerup
                    cObjectType = cCharacter;
                    iWidthObject = 16;
                    iHeightObject = 25;
                  break;
              case 'h': //meta
                    cObjectType = cCharacter;
                    iWidthObject = 83;
                    iHeightObject = 47;
                    imiImage = new ImageIcon(this.getClass().getResource(
                                                          sLevel1Finish));
                  break;
              case 'x': //salir
                    bFinishFileRead = true;
                  break;
              default:
                  break;
            }

            // agraga los datos a la lista
            //si se termino de leer el archivo
            if (!bFinishFileRead) {
                sDato = fileIn.readLine();
            }

            while (!sDato.equals("999") && !bFinishFileRead) {
                //si la linea es un comentario
                cCharacter = sDato.charAt(0);
                if (cCharacter == '/') {
                    sDato = fileIn.readLine();
                }
                int iX = Integer.parseInt(sDato);
                sDato = fileIn.readLine();
                int iY = Integer.parseInt(sDato);
                Terreno terObject;
                switch (cObjectType) {
                    case 'a': //paredes horizontal
                            terObject = new Terreno(imiImage.getImage(),
                                           iX, iY, iWidthObject, iHeightObject, false, false);
                            terObject.setImage(imiImage.getImage());
                            arlMapObjectsLevel1.add(terObject);
                        break;
                    case 'b':  //paredes vertical
                            terObject = new Terreno(imiImage.getImage(),
                                           iX, iY, iWidthObject, iHeightObject, false, false);
                            terObject.setImage(imiImage.getImage());
                            arlMapObjectsLevel1.add(terObject);
                        break;
                    case 'c': //trampas
                            terObject = new Lava(imiImage.getImage(),
                                       iX, iY, iWidthObject, iHeightObject, -1, false);
                            terObject.setImage(imiImage.getImage());
                            arlMapObjectsLevel1.add(terObject);
                        break;
                    case 'd': //puerta horizontal
                            sDato = fileIn.readLine();
                            iDoorKey = Integer.parseInt(sDato);
                            sDato = fileIn.readLine();
                            imiImage = new ImageIcon(this.getClass().getResource(
                                                          sDato));
                            terObject = new Puerta(imiImage.getImage(),
                                    iX, iY, iWidthObject, iHeightObject, false, iDoorKey, false);
                            terObject.setImage(imiImage.getImage());
                            arlMapObjectsLevel1.add(terObject);
                        break;
                    case 'e': //puerta vertical
                            sDato = fileIn.readLine();
                            iDoorKey = Integer.parseInt(sDato);
                            sDato = fileIn.readLine();
                            imiImage = new ImageIcon(this.getClass().getResource(
                                                          sDato));
                            terObject = new Puerta(imiImage.getImage(),
                                    iX, iY, iWidthObject, iHeightObject, false, iDoorKey, false);
                            terObject.setImage(imiImage.getImage());
                            arlMapObjectsLevel1.add(terObject);
                        break;
                    case 'f': //boton
                            sDato = fileIn.readLine();
                            iDoorKey = Integer.parseInt(sDato);
                            sDato = fileIn.readLine();
                            imiImage = new ImageIcon(this.getClass().getResource(
                                                          sDato));
                            terObject = new Boton(imiImage.getImage(),
                                    iX, iY, iWidthObject, iHeightObject, false, false, iDoorKey);
                            terObject.setImage(imiImage.getImage());
                            arlMapObjectsLevel1.add(terObject);
                        break;
                    case 'g': //powerup
                            sDato = fileIn.readLine();
                            int iPwrUpType = Integer.parseInt(sDato);
                            sDato = fileIn.readLine();
                            imiImage = new ImageIcon(this.getClass().getResource(
                                                          sDato));
                            terObject = new PwrUp(false, false, imiImage.getImage(),
                                    iX, iY, iWidthObject, iHeightObject, iPwrUpType, -1);
                            terObject.setImage(imiImage.getImage());
                            arlMapObjectsLevel1.add(terObject);
                        break;
                    case 'h': //meta
                            terObject = new Terreno(imiImage.getImage(),
                                           iX, iY, iWidthObject, iHeightObject, false, true);
                            terObject.setImage(imiImage.getImage());
                            arlMapObjectsLevel1.add(terObject);
                        break;
                    default:
                        break;
                }
                sDato = fileIn.readLine();
            }
        } while (!bFinishFileRead);


        iTiempoLimite = 120; //2 minutos de juego en el nivel 1

        bFocoOn = false; //no tiene el powerUp
        iFocoLimite = 3; //3 segundos de vista mejorada

        bRelojOn = false; //No tiene el powerup

        mauMauro.setX(70);
        mauMauro.setY(640);

    }

    /**
     * run
     *
     * Metodo que corre el juego y actualiza el hilo.
     *
     */
    public void run() {
        //Guarda el tiempo actual del sistema
        lCurrentTime = System.currentTimeMillis();

        //variables para el control de tiempo
        long lTimeDiff; //diferencia del tiempo contra tiempo actual en un punto
        long lSleep;    //canitdad limite para dormir el thread en ms

        //loop que cicla el juego hasta que termina
        while (!bEndGame) {
            // pinta y actualiza
            repaint();

            //actualiza datos
            AnimationCycle();

            //checa colision
            collision();

            //Calcula la diferencia de tiempo con la ultima marca de tiempo
            lTimeDiff = System.currentTimeMillis() - lCurrentTime;
            lSleep = 17 - lTimeDiff;

            //define canitdad a dormir el thread
            if (lSleep < 0)
                lSleep = 2;
            try {
                Thread.sleep(lSleep);
            } catch (InterruptedException e) {
                System.out.println("interrupted");
            }

            //actuializa el tiempo actual
            lCurrentTime = System.currentTimeMillis();
        }
    }

    /**
      * AnimationCycle
      *
      * Metodo que actualiza el juego
      *
      */
    public void AnimationCycle() {
        /*Determina el tiempo que ha transcurrido desde que el Applet inicio su
        ejecución*/
        lElapsedTime = System.currentTimeMillis() - lCurrentTime;

        //Guarda el tiempo actual
       	lCurrentTime += lElapsedTime;

        //actualiza el jugador
        mauMauro.updateMovement(iDirectionMauro);

        lightCircle();
    }

    /**
      * lightCircle
      *
      * Metodo que controla los objetos a ensenar basados en la distancia de
      * Mauro
      *
      */
    public void lightCircle(){
        //actualizar en Nivel 1 si objeto es visible
        if (iLevel == 1) {
            Iterator it = arlMapObjectsLevel1.iterator();

            if(!bFocoOn){
                iDist1 = 50;
                iDist2 = 100;
                //System.out.println("Chico");
            }
            else{
                iDist1 = 1000;
                iDist2 = 1750;
                //System.out.println("Grande");

                long lTiempoAux = System.currentTimeMillis();

                if((lTiempoAux - lFocoInicial)/1000 >= iFocoLimite){
                    bFocoOn = !bFocoOn;
                }
            }

            // mientras existan objetos en la lista
            while (it.hasNext()) {
                Terreno terObject = (Terreno) it.next();
                // revisar si estan en el area de Mauro
                if (showTerreno(terObject, mauMauro, iDist1, iDist2)) {
                    terObject.setVisible(true);
                }
                else {
                    terObject.setVisible(false);
                }
                //cambiar de nivel
                if (terObject.isExit() && mauMauro.colision(terObject)) {
                    iLevel++;
                }
            }
        }
    }

    /**
     * showTerreno
     *
     * Metodo que checa si algo esta cerca de Mauro
     *
     * @param objObject es un objeto de la clase <code>Object</code>
     * @param objMauro es un objeto de la clase <code>Object</code>
     * @return un boleano para saber si intersecta o no
     */
    public boolean showTerreno(Object objTerreno, Object objMauro, int iFactor1, int iFactor2) {

        //Crea un rectangulo para el objeto terreno
        Terreno terObject = (Terreno) objTerreno;
        Rectangle rctEsteObjeto = new Rectangle(terObject.getX(), terObject.getY(),
                terObject.getWidth(), terObject.getHeight());

        //Crea un rectangulo para Mauro, mas grande de lo que es
        Mauro mauObject = (Mauro) objMauro;
        Rectangle rctObjetoParam = new Rectangle(mauObject.getX()-iFactor1,
                mauObject.getY()-iFactor1, mauObject.getWidth()+iFactor2,
                mauObject.getHeight()+iFactor2);

        return rctEsteObjeto.intersects(rctObjetoParam);

    }

    public void collision(){

        //colision con las paredes
        Iterator it = arlMapObjectsLevel1.iterator();

        // mientras existan objetos en la lista
        while (it.hasNext()) {
            Terreno terObject = (Terreno) it.next();

            //Si el objeto es solido y existe colision...
            if(terObject.isSolid() && mauMauro.colision(terObject)){
                //Si es "lava"
                if(terObject instanceof Lava){
                    //regresar a mauro a posicion inicial
                    mauMauro.setX(70);
                    mauMauro.setY(640);
                }
                //Si es un boton, abrir puerta
                else if(terObject instanceof Boton){
                    Boton terBoton = (Boton) terObject;
                    iDoorOpenKey = terBoton.getButtonNo();
                    terBoton.setClicked(true);

                    Iterator it1 = arlMapObjectsLevel1.iterator();

                    //busca la puerta con el mismo codigo
                    while (it1.hasNext()) {
                        Terreno terObject1 = (Terreno) it1.next();
                        if(terObject1 instanceof Puerta){
                            Puerta terPuerta = (Puerta) terObject1;
                            if(terPuerta.getDoorNo() == iDoorOpenKey){
                                terPuerta.setOpen(true);
                                terPuerta.setSolid(false);
                                //terPuerta.setVisible(false);
                            }
                        }
                    }
                }
                //Si agarra un PowerUp
                else if(terObject instanceof PwrUp){
                    PwrUp terUp = (PwrUp) terObject;

                    //Si es un foco
                    if(terUp.getType() == 2){
                        if(!terUp.getGrabbed()){
                            lFocoInicial = System.currentTimeMillis();
                            bFocoOn = true;
                            terUp.setGrabbed(true);
                            terUp.setVisible(false);
                        }
                    }
                    //Si es un reloj
                    else{
                        if(!terUp.getGrabbed()){
                            bRelojOn = true;
                            terUp.setGrabbed(true);
                            terUp.setVisible(false);
                        }
                    }

                }
                //Si es una pared (o puerta solida), anular movimiento
                else{
                    if(iDirectionMauro == 1){
                        mauMauro.updateMovement(2);
                    }
                    else if(iDirectionMauro == 2){
                      mauMauro.updateMovement(1);
                    }
                    else if(iDirectionMauro == 3){
                        mauMauro.updateMovement(4);
                    }
                    else if(iDirectionMauro == 4){
                        mauMauro.updateMovement(3);
                    }
                }
            }
        }
    }

    /**
      * drawItems
      *
      * Metodo que dibuja a los items
      *
      * @param graGrafico es el <code>objeto grafico</code> usado para dibujar.
      */
    public void drawItems(Graphics graGrafico) {

    }

    /**
      * drawMauro
      *
      * Metodo que dibuja a Mauro.
      *
      * @param graGrafico es el <code>objeto grafico</code> usado para dibujar.
      */
    public void drawMauro(Graphics graGrafico) {
        // mientras exista Mauro
        if (mauMauro.isVisible() && iLevel != 0) {
            mauMauro.getAnimacion().actualiza(lElapsedTime);
            mauMauro.setAnimacion(iDirectionMauro);
            graGrafico.drawImage(mauMauro.getAnimacion().getImagen(), mauMauro.getX(),
                                                mauMauro.getY(), this);
        }

        /*// si el juegador se muere termina el juego
        if (mauMauro.isDying()) {
            plyPlayer.die();
            bIngame = false;
        }*/
    }

    /**
      * drawEnemigos
      *
      * Metodo que dibuja a los enemigos.
      *
      * @param graGrafico es el <code>objeto grafico</code> usado para dibujar.
      */
    public void drawEnemigos(Graphics graGrafico) {

    }

    /**
      * drawTerrenos
      *
      * Metodo que dibuja los terrenos
      *
      * @param graGrafico es el <code>objeto grafico</code> usado para dibujar.
      */
    public void drawTerrenos(Graphics graGrafico) {
        //dependiendo del nivel se pintara dichos objetos
        switch (iLevel) {
            case 1:
                Iterator it = arlMapObjectsLevel1.iterator();

                // mientras existan objetos en la lista
                while (it.hasNext()) {

                    Terreno terObject = (Terreno) it.next();

                    if(terObject instanceof Lava){
                        Lava terTrap = (Lava) terObject;

                        if (terTrap.isVisible()) {
                            terTrap.getAnimacion().actualiza(lElapsedTime);
                            graGrafico.drawImage(terTrap.getAnimacion().getImagen(), terTrap.getX(),
                                                terTrap.getY(), this);
                        }
                    }

                    //si es una puerta
                    else if(terObject instanceof Puerta){

                        Puerta terDoor = (Puerta) terObject;

                        if (terDoor.isVisible() && !terDoor.isOpen()) {
                            graGrafico.drawImage(terDoor.getImage(), terDoor.getX(),
                                                        terDoor.getY(), this);
                        }


                    }
                    //si es un boton
                    else if(terObject instanceof Boton){

                        Boton terBoton = (Boton) terObject;

                        if(terBoton.isVisible() && !terBoton.getClicked()){
                            graGrafico.drawImage(terBoton.getImage(), terBoton.getX(),
                                                        terBoton.getY(), this);
                        }
                    }
                    //Si es un powerup
                    else if(terObject instanceof PwrUp){
                        PwrUp terUp = (PwrUp) terObject;

                        if(terUp.isVisible() && !terUp.getGrabbed()){
                            graGrafico.drawImage(terUp.getImage(), terUp.getX(),
                                                        terUp.getY(), this);
                        }
                    }
                //si es una pared
                else if (terObject.isVisible()) {
                    graGrafico.drawImage(terObject.getImage(), terObject.getX(),
                                                        terObject.getY(), this);

                }



            }
                break;
            case 2:

                break;
            case 3:

                break;
            case 4:

                break;
            default:

                break;
          }
    }

    /**
      * drawGameOver
      *
      * Metodo que dibuja el game over
      *
      * @param graGrafico es el <code>objeto grafico</code> usado para dibujar.
      */
    public void drawGameOver(Graphics graGrafico) {

    }

    /**
      * drawTimeBar
      *
      * Metodo que dibuja la barra del tiempo
      *
      * @param graGrafico es el <code>objeto grafico</code> usado para dibujar.
      */
    public void drawTimeBar(Graphics graGrafico){
        //Crea el fondo de la barra de tiempo
        String sBar = "Menus/barraTiempo_Fondo.png";
        ImageIcon imiImage = new ImageIcon(this.getClass().getResource(sBar));
        graGrafico.drawImage(imiImage.getImage(), 0, iHeight-41, this);

        //Saca el tiempo actual
        lBarraActual = System.currentTimeMillis();

        //Saca el tiempo que ha pasado desde el inicio del nivel
        iBarraElapsed = (int)(lBarraActual - lBarraInicial)/1000;

        if(bRelojOn){
            lBarraInicial += 8000;
            bRelojOn = !bRelojOn;
        }

        if (iTiempoLimite - iBarraElapsed > 0) {
        //Se dibuja la barra verde que se modifica con el tiempo
        graGrafico.setColor(Color.GREEN);
        graGrafico.fillRect(85, iHeight-38,(1115/iTiempoLimite)*(iTiempoLimite-iBarraElapsed),
                13);
        }

        else {
            bGameOver = true;
            iLevel = 5;
            System.out.println("barra");
        }

        /**if (bGameOver) {
            String sGameOver = "Menus/gameover.png";
            ImageIcon imiImageGameOver = new ImageIcon(this.getClass().getResource(sGameOver));
            graGrafico.drawImage(imiImageGameOver.getImage(), 0, 0, this);
            //boton
            mbtGameOverMenu.paint(graGrafico, this);
            mbtGameOverMenu.setVisible(true);
            iLevel = 5;
        }**/


    }

    /**
      * drawMenu
      *
      * Metodo que dibuja el menu y los submenús.
      *
      * @param graGrafico es el <code>objeto grafico</code> usado para dibujar.
      */
    public void drawMenu(Graphics graGrafico) {
        // Switch que se utiliza para ver qué pantalla desplegar
        switch (iMenu) {
            case 1: {   // se despliega la portada
                URL urlMenu = this.getClass().getResource("Menus/menu1.png");
                Image imaMenu = Toolkit.getDefaultToolkit().getImage(urlMenu);
                graGrafico.drawImage(imaMenu, 0, 0, this);
                break;
            }
            case 2: {
                // se despliega la segunda portada
            }
            case 3: { // se despliega el MENU
                // dibuja el fondo
                URL urlMenu = this.getClass().getResource("Menus/menu3.png");
                Image imaMenu = Toolkit.getDefaultToolkit().getImage(urlMenu);
                graGrafico.drawImage(imaMenu, 0, 0, this);
                // dibuja los botones
                mbtPlay.paint(graGrafico, this);
                mbtInstruc.paint(graGrafico, this);
                mbtAbout.paint(graGrafico, this);
                mbtOptions.paint(graGrafico, this);
                mbtScores.paint(graGrafico, this);
                mbtExit.paint(graGrafico, this);
                // pone el estado de los botones en visible
                mbtPlay.setVisible(true);
                mbtInstruc.setVisible(true);
                mbtOptions.setVisible(true);
                mbtAbout.setVisible(true);
                mbtScores.setVisible(true);
                mbtExit.setVisible(true);
                break;
            }
            case 4: { // se dibujan las instrucciones
                // dibuja el fondo
                URL urlMenu = this.getClass().getResource("Menus/menu4.png");
                Image imaMenu = Toolkit.getDefaultToolkit().getImage(urlMenu);
                graGrafico.drawImage(imaMenu, 0, 0, this);
                // dibuja el botón back y lo pone visible
                mbtBack.paint(graGrafico, this);
                mbtBack.setVisible(true);
                break;
            }
            case 5: { // se dibujan las opciones
                URL urlMenu = this.getClass().getResource("Menus/menu5.png");
                Image imaMenu = Toolkit.getDefaultToolkit().getImage(urlMenu);
                graGrafico.drawImage(imaMenu, 0, 0, this);
                // dibuja el botón back y lo pone visible
                mbtBack.paint(graGrafico, this);
                mbtBack.setVisible(true);
                break;
            }
            case 6: { // se dibuja el acerca
                URL urlMenu = this.getClass().getResource("Menus/menu6.png");
                Image imaMenu = Toolkit.getDefaultToolkit().getImage(urlMenu);
                graGrafico.drawImage(imaMenu, 0, 0, this);
                // dibuja el botón back y lo pone visible
                mbtBack.paint(graGrafico, this);
                mbtBack.setVisible(true);
                break;
            }
            case 7: { // se dibujan los puntajes
                URL urlMenu = this.getClass().getResource("Menus/menu7.png");
                Image imaMenu = Toolkit.getDefaultToolkit().getImage(urlMenu);
                graGrafico.drawImage(imaMenu, 0, 0, this);
                // dibuja el botón back y lo pone visible
                mbtBack.paint(graGrafico, this);
                mbtBack.setVisible(true);
                break;
            }
        }
    }

    /**
      * Metodo <I>paint</I> sobrescrito de la clase <code>JPanel</code>,
      * heredado de la clase Container.<P>
      * En este metodo se dibuja la imagen con la posicion actualizada,
      * ademas que cuando la imagen es cargada te despliega una advertencia.
      * @param graGrafico es el <code>objeto grafico</code> usado para dibujar.
      */
    public void paint(Graphics graGrafico) {
      //llama al paint de la clase que heredaste
      super.paint(graGrafico);

        if (!bEndGame) {
            switch (iLevel) {
                case -1: //animacion inical

                    break;
                case 0:    //menu
                    drawMenu(graGrafico);
                    graGrafico.setColor(Color.decode("#1d2e4c"));
                    break;
                case 1:
                    Graphics2D g2d = (Graphics2D) graGrafico;
                    g2d.setColor(Color.decode("#1d2e4c"));
                    g2d.fillOval(mauMauro.getX()-40, mauMauro.getY()-35, 100, 100);
                    g2d.drawOval(mauMauro.getX()-40, mauMauro.getY()-35, 100, 100);
                    setBackground(Color.black);
                    drawTerrenos(graGrafico);
                    drawMauro(graGrafico);
                    if (!bGameOver) {
                        drawTimeBar(graGrafico);
                    }
                    break;
                case 2:
                    String sNextLevel = "Menus/mensaje.png";
                    ImageIcon imiImageGameOver = new ImageIcon(this.getClass().getResource(sNextLevel));
                    graGrafico.drawImage(imiImageGameOver.getImage(), 0, 0, this);
                    //boton
                    mbtGameOverMenu.paint(graGrafico, this);
                    mbtGameOverMenu.setVisible(true);
                    break;
                case 3:
                    graGrafico.setColor(Color.decode("#1d2e4c"));
                    break;
                case 4:
                    graGrafico.setColor(Color.decode("#1d2e4c"));
                    break;
                default:
                    graGrafico.setColor(Color.black);
                    String sGameOver = "Menus/gameover.png";
                    ImageIcon imiImageGameOver2 = new ImageIcon(this.getClass().getResource(sGameOver));
                    graGrafico.drawImage(imiImageGameOver2.getImage(), 0, 0, this);
                    //boton
                    mbtGameOverMenu.paint(graGrafico, this);
                    mbtGameOverMenu.setVisible(true);
                    break;
            }

        }

        //si el juego termino
        else {

        }

      //comandos para paint
      Toolkit.getDefaultToolkit().sync();
      graGrafico.dispose();
    }

    /**
     * keyTyped
     *
     * Metodo sobrescrito de la interface <code>KeyListener</code>.<P>
     * En este metodo maneja el evento que se genera al presionar una
     * tecla que no es de accion.
     *
     * @param keyEvent es el <code>KeyEvent</code> que se genera en al
     * presionar.
     *
     */
    public void keyTyped(KeyEvent keyEvent) {
        // no hay codigo pero se debe escribir el metodo
    }

    /**
     * keyPressed
     *
     * Metodo sobrescrito de la interface <code>KeyListener</code>.<P>
     * En este metodo maneja el evento que se genera al dejar presionada
     * alguna tecla.
     * Se cambia la direccion al presionar una tecla
     *
     * @param keyEvent es el <code>KeyEvent</code> que se genera en al
     * presionar.
     *
     */
    public void keyPressed(KeyEvent keyEvent) {
        // si presiono la flecha arriba
        if(keyEvent.getKeyCode() == KeyEvent.VK_UP) {
            iDirectionMauro = 1;
        }
        // si presiono la flecha abajo
        else if(keyEvent.getKeyCode() == KeyEvent.VK_DOWN) {
            iDirectionMauro = 2;
        }
        // si presiono la flecha izquierda
        else if(keyEvent.getKeyCode() == KeyEvent.VK_LEFT) {
            iDirectionMauro = 3;
        }
        // si presiono la flecha derecha
        else if(keyEvent.getKeyCode() == KeyEvent.VK_RIGHT) {
            iDirectionMauro = 4;
        }
    }

    /**
     * keyReleased
     * Metodo sobrescrito de la interface <code>KeyListener</code>.<P>
     * En este metodo maneja el evento que se genera al soltar la tecla.
     *
     * @param keyEvent es el <code>KeyEvent</code> que se genera en al soltar.
     *
     */
    public void keyReleased(KeyEvent keyEvent) {
        // si presiono la flecha arriba
        if(keyEvent.getKeyCode() == KeyEvent.VK_UP) {
            iDirectionMauro = 0;
        }
        // si presiono la flecha abajo
        else if(keyEvent.getKeyCode() == KeyEvent.VK_DOWN) {
            iDirectionMauro = 0;
        }
        // si presiono la flecha izquierda
        else if(keyEvent.getKeyCode() == KeyEvent.VK_LEFT) {
            iDirectionMauro = 0;
        }
        // si presiono la flecha derecha
        else if(keyEvent.getKeyCode() == KeyEvent.VK_RIGHT) {
            iDirectionMauro = 0;
        }
    }

  /**
     * mouseClicked
     *
     * Metodo sobrescrito de la clase <code>MouseListener</code>.<P>
     * En este metodo maneja el evento que se genera al clickear el mouse.
     *
     * @param mseEvent es el <code>MouseEvent</code> que se genera en
     * al presionar.
     *
     */
    public void mouseClicked(MouseEvent mseEvent) {
        // no se utiliza
    }

   /**
     * mousePressed
     *
     * Metodo sobrescrito de la clase <code>MouseListener</code>.<P>
     * En este metodo maneja el evento que se genera al presionar el mouse.
     *
     * @param mseEvent es el <code>MouseEvent</code> que se genera en
     * al presionar.
     *
     */
    public void mousePressed(MouseEvent mseEvent) {
        // no se utiliza
    }

   /**
     * mouseReleased
     *
     * Metodo sobrescrito de la clase <code>MouseListener</code>.<P>
     * En este metodo maneja el evento que se genera al soltar el mouse.
     *
     * @param mseEvent es el <code>MoseEvent</code> que se genera en
     * al presionar.
     *
     */
    public void mouseReleased(MouseEvent mseEvent) {
        // variables que guardan la posición del mouse
        iMouseX = mseEvent.getX();
        iMouseY = mseEvent.getY();

        /* Checa si el mouse colisiona con algún botón y cambia la variable de
         menú a la adecuada.
        */
        if (mbtBack.isVisible() && mbtBack.intersectaMouse(iMouseX, iMouseY)) {
            iMenu = 3;
            mbtBack.setVisible(false);
        }
        else if (mbtPlay.isVisible() && mbtPlay.intersectaMouse(iMouseX, iMouseY)) {
            iMenu = 3;
            mbtPlay.setVisible(false);
            mbtInstruc.setVisible(false);
            mbtOptions.setVisible(false);
            mbtAbout.setVisible(false);
            mbtScores.setVisible(false);
            mbtExit.setVisible(false);
            bPlay = true;
            iLevel = 1;
            lBarraInicial = System.currentTimeMillis()+5000; //saca el tiempo en donde inicia el juego
            //Se define sonido de fondo
            sndSonidoFondo1 = new SoundClip("Musica/nivel1.wav");
            sndSonidoFondo1.setLooping(true);
            sndSonidoFondo1.play();
            bGameOver = false;
        }
        else if (mbtInstruc.isVisible() && mbtInstruc.intersectaMouse(iMouseX, iMouseY)) {
            iMenu = 4;
            mbtPlay.setVisible(false);
            mbtInstruc.setVisible(false);
            mbtOptions.setVisible(false);
            mbtAbout.setVisible(false);
            mbtScores.setVisible(false);
            mbtExit.setVisible(false);
        }
        else if (mbtOptions.isVisible() && mbtOptions.intersectaMouse(iMouseX, iMouseY)) {
            iMenu = 5;
            mbtPlay.setVisible(false);
            mbtInstruc.setVisible(false);
            mbtOptions.setVisible(false);
            mbtAbout.setVisible(false);
            mbtScores.setVisible(false);
            mbtExit.setVisible(false);
        }
        else if (mbtAbout.isVisible() && mbtAbout.intersectaMouse(iMouseX, iMouseY)) {
            iMenu = 6;
            mbtPlay.setVisible(false);
            mbtInstruc.setVisible(false);
            mbtOptions.setVisible(false);
            mbtAbout.setVisible(false);
            mbtScores.setVisible(false);
            mbtExit.setVisible(false);
        }
        else if (mbtScores.isVisible() && mbtScores.intersectaMouse(iMouseX, iMouseY)) {
            iMenu = 7;
            mbtPlay.setVisible(false);
            mbtInstruc.setVisible(false);
            mbtOptions.setVisible(false);
            mbtAbout.setVisible(false);
            mbtScores.setVisible(false);
            mbtExit.setVisible(false);
        }
        else if (mbtGameOverMenu.isVisible() && mbtGameOverMenu.intersectaMouse(iMouseX, iMouseY)) {
            iMenu = 3;
            iLevel = 0;
            mbtGameOverMenu.setVisible(false);
            try {
                GameInitMaps();
                //bGameOver = false;
            } catch (IOException ex) {
                Logger.getLogger(Board.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        else if (mbtExit.isVisible() && mbtExit.intersectaMouse(iMouseX, iMouseY)) {
            System.exit(0);
        }



    }

   /**
     * mouseEntered
     *
     * Metodo sobrescrito de la clase <code>MouseListener</code>.<P>
     * En este metodo maneja el evento que se genera cuando el mouse entra en
     * el applet.
     *
     * @param mseEvent es el <code>MoseEvent</code> que se genera en
     * al presionar.
     *
     */
    public void mouseEntered(MouseEvent mseEvent) {
        // no se utiliza
    }

   /**
     * mouseExited
     *
     * Metodo sobrescrito de la clase <code>MouseListener</code>.<P>
     * En este metodo maneja el evento que se genera cuando el mouse sale en
     * el applet.
     *
     * @param mseEvent es el <code>MoseEvent</code> que se genera en
     * al presionar.
     *
     */
    public void mouseExited(MouseEvent mseEvent) {
        // no se utiliza
    }

}