package MyGame;

import java.util.Random;
import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.Image;
import javax.microedition.lcdui.game.GameCanvas;
import javax.microedition.lcdui.game.Sprite;
import javax.microedition.lcdui.game.TiledLayer;

/**
 * Implementa el juego.
 * @author IntelligentSoft
 */
public class clsCanvas extends GameCanvas implements Runnable {

// key repeat rate en milisegundos
public static final int keyDelay = 250;    


public static final int fireKey = 4;

//estados de las teclas para up, left, down, right, y tecla disparo
private boolean[] isDown = {
    false, false, false, false, false
};

//última vez que la tecla cambió de estado
private long[] keyTick = {
    0, 0, 0, 0, 0
};

//buscar en la tabla para constantes de teclas
private int[] keyValue = {
    GameCanvas.UP_PRESSED, GameCanvas.LEFT_PRESSED,
    GameCanvas.DOWN_PRESSED, GameCanvas.RIGHT_PRESSED, 
    GameCanvas.FIRE_PRESSED
};

private boolean isRunning = true;    
private Graphics g;
private midMain fParent;

// Secuencia hacia frente
int[] sequence1 = {0,1,2,3,4,5,6,7};
// Secuencia a derecha
int[] sequence2 = {8,9,10,11,12,13,14,15};
// Secuencia hacia arriba
int[] sequence3 = {16,17,18,19,20,21,22,23};
// Secuancia a izquierda
int[] sequence4 = {24,25,26,27,28,29,30,31};

int up=0;
int down=0;
int left=0;
int right=0;

int cont = 0;

private Image imgLolo;
private Sprite Heroe;
private Sprite Enem1;
private Sprite Enem2;
private Sprite Enem3;
private Sprite Enem4;
private Sprite Enem5;
private Sprite Enem6;
private Sprite Enem7;
private Sprite Enem8;
private Sprite Enem9;
private Sprite Enem10;
private Sprite Enem11;
private Sprite Enem12;
private Sprite Enem13;
private Sprite Enem14;
private Sprite Enem15;
private Sprite Enem16;
private Sprite Enem17;
private Sprite Enem18;
private Sprite Enem19;
private Sprite Enem20;
private Sprite Enem21;
private Sprite Enem22;
private Sprite Enem23;

private int vanSpeed = 2;
private int enem1Speed = 1;
private int enem2Speed = 1;
private int enem3Speed = 3;
private int enem4Speed = 3;
private int enem5Speed = 5;
private int enem6Speed = 5;
private int enem7Speed = 2;
private int enem8Speed = 2;
private int enem9Speed = 2;
private int enem10Speed = 2;
private int enem11Speed = 2;
private int enem12Speed = 2;
private int enem13Speed = 2;
private int enem14Speed = 2;
private int enem15Speed = 2;
private int enem16Speed = 2;
private int enem17Speed = 1;
private int enem18Speed = 1;
private int enem19Speed = 1;
private int enem20Speed = 1;
private int enem21Speed = 5;
private int enem22Speed = 2;
private int enem23Speed = 2;



private Image imgTileset;
private Image imgTileset1;
private Image imgTileset2;
private Image imgTilesetE;
private TiledLayer roadMap;
private TiledLayer blockMap;
private TiledLayer blockMap1;
private TiledLayer blockMap2;

    /**
     * Constructor
     * @param m clase principal que crea el midlet
     */
    public clsCanvas(midMain m) {
        super(true);
        fParent = m;
        setFullScreenMode(true);
    }
    
    /**
     * Inicia el thread o hilo
     */
    public void start(){
        Thread runner = new Thread(this);
        runner.start();
    }
    
    /**
    * Carga el los gráficos del nivel (piso)
    */
    public void loadRoadMap(){
        //inicializar roadMap
        roadMap = new TiledLayer(15, 20, imgTileset, 16, 16);
        
        // Crear nuevo Random para numeros al azar
        Random Rand = new Random();
        
        //recorre todas las celdas del mapa
        for (int y = 0; y < 20; y++){
            for (int x = 0; x < 15; x++){
                //obtener un número aleatorio entre 2 y 5
                int index = (Math.abs(Rand.nextInt()>>>1) % (3)) + 2;
                
                //asigna el índice de tile para la celda actual
                roadMap.setCell(x, y, index);
            }          
        }
        
        roadMap.setCell(13, 18, 1);
        
        Rand = null;
    }
    /**
     * Carga el mapa del nivel
     * @param nivel nivel a cargar 
     */
    public void loadBlockMap(int nivel){
        // define el número de tile a ser usado en cada celda del mapa
        byte[][] blockData1 = {
            {10, 8 , 7 , 6 , 10, 9 , 8 , 7 , 6 , 10, 9 , 9 , 9 , 9 , 9 },  
            {6 , 0 , 0 , 0 , 6 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 8 },  
            {7 , 0 , 0 , 0 , 6 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 7 },  
            {8 , 0 , 0 , 0 , 6 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 6 },  
            {9 , 0 , 0 , 0 , 6 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 10},  
            {10, 0 , 0 , 0 , 6 , 0 , 0 , 0 , 0 , 7 , 0 , 0 , 0 , 0 , 9 },  
            {6 , 0 , 0 , 0 , 6 , 0 , 0 , 0 , 0 , 7 , 0 , 0 , 0 , 0 , 8 },  
            {7 , 0 , 0 , 0 , 6 , 0 , 0 , 0 , 0 , 7 , 0 , 0 , 0 , 0 , 7 },  
            {8 , 0 , 0 , 0 , 6 , 0 , 0 , 0 , 0 , 7 , 0 , 0 , 0 , 0 , 6 },  
            {9 , 0 , 0 , 0 , 6 , 0 , 0 , 0 , 0 , 7 , 0 , 0 , 0 , 0 , 10},  
            {10, 0 , 0 , 0 , 6 , 0 , 0 , 0 , 0 , 7 , 0 , 0 , 0 , 0 , 9 },  
            {6 , 0 , 0 , 0 , 6 , 0 , 0 , 0 , 0 , 7 , 0 , 0 , 0 , 0 , 8 },  
            {7 , 0 , 0 , 0 , 6 , 0 , 0 , 0 , 0 , 7 , 0 , 0 , 0 , 0 , 7 },
            {7 , 0 , 0 , 0 , 6 , 0 , 0 , 0 , 0 , 7 , 0 , 0 , 0 , 0 , 7 },
            {7 , 0 , 0 , 0 , 6 , 0 , 0 , 0 , 0 , 7 , 0 , 0 , 0 , 0 , 7 },
            {7 , 0 , 0 , 0 , 6 , 0 , 0 , 0 , 0 , 7 , 0 , 0 , 0 , 0 , 7 },
            {7 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 7 , 0 , 0 , 0 , 0 , 7 },
            {7 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 7 , 0 , 0 , 0 , 0 , 7 },
            {7 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 7 , 0 , 0 , 0 , 0 , 7 },
            {7 , 8 , 9 , 10, 6 , 7 , 8 , 9 , 10, 6 , 9 , 9 , 7 , 7 , 10}
            
        };
        
        byte[][] blockData2 = {
            {10, 8 , 7 , 6 , 10, 9 , 8 , 7 , 6 , 10, 9 , 9 , 9 , 9 , 9 },  
            {6 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 8 },  
            {7 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 7 },  
            {8 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 6 },  
            {9 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 10},  
            {10, 0 , 0 , 0 , 8 , 8 , 8 , 9 , 8 , 8 , 8 , 8 , 8 , 8 , 9 },  
            {6 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 8 },  
            {7 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 7 },  
            {8 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 6 },  
            {9 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 10},  
            {6 , 7 , 7 , 7 , 8 , 8 , 8 , 8 , 8 , 8 , 8 , 9 , 0 , 0 , 8 },  
            {8 , 0 , 0 , 0 , 0 , 6 , 0 , 0 , 6 , 0 , 0 , 6 , 0 , 0 , 6 }, 
            {7 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 7 },
            {7 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 7 },
            {7 , 0 , 0 , 8 , 8 , 8 , 8 , 8 , 8 , 8 , 8 , 8 , 8 , 8 , 7 },
            {7 , 0 , 0 , 0 , 6 , 6 , 0 , 0 , 9 , 9 , 9 , 0 , 0 , 0 , 7 },
            {7 , 0 , 0 , 0 , 6 , 6 , 0 , 0 , 9 , 9 , 9 , 0 , 0 , 0 , 7 },
            {7 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 7 },
            {7 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 7 },
            {7 , 8 , 9 , 10, 6 , 7 , 8 , 9 , 10, 6 , 9 , 9 , 7 , 7 , 10}
            
        };
        
        byte[][] blockData3 = {
            {10, 8 , 7 , 6 , 10, 9 , 8 , 7 , 6 , 10, 9 , 9 , 9 , 9 , 9 },  
            {7 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 7 },
            {7 , 0 , 0 , 6 , 6 , 0 , 7 , 0 , 8 , 0 , 0 , 8 , 0 , 0 , 7 },
            {7 , 0 , 0 , 6 , 0 , 0 , 7 , 0 , 8 , 8 , 0 , 8 , 0 , 0 , 7 },
            {7 , 0 , 0 , 6 , 6 , 0 , 7 , 0 , 8 , 0 , 8 , 8 , 0 , 0 , 7 },
            {7 , 0 , 0 , 6 , 0 , 0 , 7 , 0 , 8 , 0 , 0 , 8 , 0 , 0 , 7 },
            {7 , 0 , 0 , 6 , 0 , 0 , 7 , 0 , 8 , 0 , 0 , 8 , 0 , 0 , 7 },
            {7 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 7 },
            {7 , 0 , 0 , 9 , 9 , 0 , 0 , 0 , 6 , 0 , 6 , 0 , 0 , 0 , 7 }, 
            {7 , 0 , 0 , 9 , 0 , 9 , 0 , 0 , 6 , 6 , 6 , 0 , 0 , 0 , 7 },
            {7 , 0 , 0 , 9 , 0 , 9 , 10, 10, 6 , 0 , 6 , 8 , 8 , 8 , 7 },
            {7 , 0 , 0 , 9 , 0 , 9 , 10, 0 , 6 , 0 , 6 , 8 , 0 , 8 , 7 },
            {7 , 0 , 0 , 9 , 9 , 0 , 10, 10, 6 , 0 , 6 , 8 , 0 , 8 , 7 },
            {7 , 0 , 0 , 0 , 0 , 0 , 10, 0 , 0 , 0 , 0 , 8 , 0 , 8 , 7 },
            {7 , 0 , 0 , 0 , 0 , 0 , 10, 10, 0 , 0 , 0 , 8 , 8 , 8 , 7 },
            {7 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 7 },
            {7 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 7 },
            {7 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 6 , 6 , 7 },
            {7 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 6 , 0 , 7 },
            {7 , 8 , 9 , 10, 6 , 7 , 8 , 9 , 10, 6 , 9 , 9 , 7 , 7 , 10}
            
        };
        
        //initialize blockMap, aquí se define el tamano de blockmap
        //dos primeros numeros definen el tamano x,y
        blockMap = new TiledLayer(15, 20, imgTileset, 16, 16);
        blockMap1 = new TiledLayer(15, 20, imgTileset1, 16, 16);
        blockMap2 = new TiledLayer(15, 20, imgTileset2, 16, 16);
        
        //recorre todas las celdas del mapa
        for (int y = 0; y < 20; y++){
            for (int x = 0; x < 15; x++){
                // asignar el índice de tile a ser usada en la celda actual
                // notar indices invertidos para acceder a blockdata (fila,col)
                if (nivel == 1)
                   blockMap.setCell(x, y, blockData1[y][x]);  
                else if (nivel == 2)
                   blockMap1.setCell(x, y, blockData2[y][x]);
                else if (nivel == 3)
                    blockMap2.setCell(x, y, blockData3[y][x]);
                

            }
        }
        
        blockData1 = null;
        blockData2 = null;
        blockData3 = null;
    }
    /**
     * Codigo de inicializacion del juego
     * Carga las imagenes que conformaran los personajes y el mapa
     * @param nivel el nivel que se desea cargar
     */
    public void load(int nivel){
        try{
            // aqui se cargan las imagenes
            imgLolo = Image.createImage("/images/jugador.png");
            
            imgTileset = Image.createImage("/images/tileset1_1.png");
            imgTileset1 = Image.createImage("/images/tileset2.png");
            imgTileset2 = Image.createImage("/images/tileset3.png");
            imgTilesetE = Image.createImage("/images/malos2.png");
        }catch(Exception ex){
            // salir de la aplicacion si ni se logra cargar una imagen
            isRunning = false;
            return;
        }
        
        // inicialiar el objeto sprite
        // Sprite(objeto que contiene frames, ancho, alto)
        Heroe = new Sprite(imgLolo, 18, 18);
        /***************ENEMIGOS*********************/
        
            Enem1 = new Sprite(imgTilesetE, 16, 16);
            Enem1.setFrame(5);
            Enem1.setPosition(32, 80);
            Enem2 = new Sprite(imgTilesetE, 16, 16);
            Enem2.setFrame(6);
            Enem2.setPosition(32, 160);
            Enem3 = new Sprite(imgTilesetE, 16, 16);
            Enem3.setFrame(7);
            Enem3.setPosition(80, 160);
            Enem4 = new Sprite(imgTilesetE, 16, 16);
            Enem4.setFrame(8);
            Enem4.setPosition(96, 160);
            Enem5 = new Sprite(imgTilesetE, 16, 16);
            Enem5.setFrame(9);
            Enem5.setPosition(112, 160);
            Enem6 = new Sprite(imgTilesetE, 16, 16);
            Enem6.setFrame(5);
            Enem6.setPosition(128, 160);
            Enem7 = new Sprite(imgTilesetE, 16, 16);
            Enem7.setFrame(6);
            Enem7.setPosition(192, 96);
            Enem8 = new Sprite(imgTilesetE, 16, 16);
            Enem8.setFrame(7);
            Enem8.setPosition(192, 112);
            Enem9 = new Sprite(imgTilesetE, 16, 16);
            Enem9.setFrame(8);
            Enem9.setPosition(192, 128);
            Enem10 = new Sprite(imgTilesetE, 16, 16);
            Enem10.setFrame(9);
            Enem10.setPosition(160, 176);
            Enem11 = new Sprite(imgTilesetE, 16, 16);
            Enem11.setFrame(5);
            Enem11.setPosition(160, 192);
            Enem12 = new Sprite(imgTilesetE, 16, 16);
            Enem12.setFrame(6);
            Enem12.setPosition(160, 208);
            Enem13 = new Sprite(imgTilesetE, 16, 16);
            Enem13.setFrame(7);
            Enem13.setPosition(64, 48);
            Enem14 = new Sprite(imgTilesetE, 16, 16);
            Enem14.setFrame(8);
            Enem14.setPosition(112, 32);
            Enem15 = new Sprite(imgTilesetE, 16, 16);
            Enem15.setFrame(9);
            Enem15.setPosition(160, 48);
            Enem16 = new Sprite(imgTilesetE, 16, 16);
            Enem16.setFrame(5);
            Enem16.setPosition(128, 112);
            Enem17 = new Sprite(imgTilesetE, 16, 16);
            Enem17.setFrame(6);
            Enem17.setPosition(144, 112);
            Enem18 = new Sprite(imgTilesetE, 16, 16);
            Enem18.setFrame(7);
            Enem18.setPosition(128, 144);
            Enem19 = new Sprite(imgTilesetE, 16, 16);
            Enem19.setFrame(8);
            Enem19.setPosition(144, 144);
            Enem20 = new Sprite(imgTilesetE, 16, 16);
            Enem20.setFrame(9);
            Enem20.setPosition(80, 128);
            Enem21 = new Sprite(imgTilesetE, 16, 16);
            Enem21.setFrame(5);
            Enem21.setPosition(160, 208);
            Enem22 = new Sprite(imgTilesetE, 16, 16);
            Enem22.setFrame(6);
            Enem22.setPosition(112, 272);
            Enem23 = new Sprite(imgTilesetE, 16, 16);
            Enem23.setFrame(7);
            Enem23.setPosition(112, 288);
        
        /**********************************************/
        
        // los frames se cuentan de izquierda a derecha 
        // en la imagen origen
        Heroe.setFrame(0);
               
        // move to 16, 16 (X, Y)
        Heroe.setPosition(16, 16);
        
        loadRoadMap();
        loadBlockMap(nivel);
        
    }
    
    /**
     * Asegura la destruccion de los objeto
     */
    public void unload(){
        blockMap = null;
        blockMap1 = null;
        blockMap2 = null;
        roadMap = null;
        Heroe = null;
        /********************ENEMIGOS********/
        Enem1 = null;
        Enem2 = null;
        Enem3 = null;
        Enem4 = null;
        Enem5 = null;
        Enem6 = null;
        Enem7 = null;
        Enem8 = null;
        Enem9 = null;
        Enem10 = null;
        Enem11 = null;
        Enem12 = null;
        Enem13 = null;
        
        Enem14 = null;
        Enem15 = null;
        Enem16 = null;
        Enem17 = null;
        Enem18 = null;
        Enem19 = null;
        Enem20 = null;
        Enem21 = null;
        Enem22 = null;
        Enem23 = null;
        /************************************/
        imgTileset = null;
        imgLolo = null;
    }
 /**
 * Comprueba qué teclas estan presionadas
 * @param iKey estado de teclas
 * @param currTick timepo actual 
 */
    public void checkKeys(int iKey, long currTick){
        long elapsedTick = 0;
        //recorrer las teclas
        for (int i = 0; i < 5; i++){ 
            //por defecto, tecla no apretada por usuario
            isDown[i] = false;
            //está el usuiario presionando la tecla?
            if ((iKey & keyValue[i]) != 0){ 
                elapsedTick = currTick - keyTick[i];
                //es tiempo de cambiar el estado de la tecla?
                if (elapsedTick >= keyDelay){ 
                   //guardar el tiempo actual
                    keyTick[i] = currTick;  
                    //toggle estado a presionada
                    isDown[i] = true; 
                }
            }
        }
    }
    
    
      
    /**
     * Contiene el loop principal y la mayoria del código del juego
     */
    public void run() {
       int iKey = 0;
       int screenW = getWidth();
       int screenH = getHeight();
       long lCurrTick = 0; // tiempo actual del sistema en milisegundos
       /***********ENEMIGOS************/
       int en1left = 1;
       int en2left = 0;
       int en3up = 1;
       int en4up = 1;
       int en5up = 0;
       int en6up = 0;
       int en7left = 1;
       int en8left = 1;
       int en9left = 1;
       int en10left = 0;
       int en11left = 0;
       int en12left = 0;
       int en13up = 1;
       int en14up = 0;
       int en15up = 1;
       int en16up = 0;
       int en17up = 0;
       int en18up = 1;
       int en19up = 1;
       int en20up = 0;
       int en21left = 1;
       int en22left = 0;
       int en23left = 1;
       /*******************************/
       int nivelActual = 1;
       load(nivelActual);
       g = getGraphics();
       
       while(isRunning){
           
           lCurrTick = System.currentTimeMillis();
           iKey = getKeyStates();
           
           checkKeys(iKey, lCurrTick);
           
           //Si la tecla de disparo o tecla 5 es presionada
           //se termina el loop y la aplicacion
           if (isDown[fireKey]){
               isRunning = false;    
           }
           
           // obtener la posicion actual del heroe
           int cx = Heroe.getX();
           int cy = Heroe.getY();
           
           /****************ENEMIGOS****************/
           
           
           // obtener posición enemigo 1
           int e1x = Enem1.getX();int e1y = Enem1.getY();
           // movimiento de enemigo 1 izquierda o derecha
           if(en1left == 1)       e1x -= enem1Speed;    
           else if(en1left == 0)  e1x += enem1Speed;
           //Posicion actual enemigo 1
           int e1tx = e1x;int e1ty = e1y;
           // obtener posición enemigo 2
           int e2x = Enem2.getX();int e2y = Enem2.getY();
           // movimiento de enemigo 2 izquierda o derecha
           if(en2left == 1)       e2x -= enem2Speed;    
           else if(en2left == 0)  e2x += enem2Speed;
           //Posicion actual enemigo 2
           int e2tx = e2x;int e2ty = e2y;
           // obtener posición enemigo 3
           int e3x = Enem3.getX();int e3y = Enem3.getY();
           // movimiento de enemigo 3 izquierda o derecha
           if(en3up == 0)       e3y -= enem3Speed;    
           else if(en3up == 1)  e3y += enem3Speed;
           //Posicion actual enemigo 3
           int e3tx = e3x;int e3ty = e3y;
           // obtener posición enemigo 4
           int e4x = Enem4.getX();int e4y = Enem4.getY();
           // movimiento de enemigo 4 izquierda o derecha
           if(en4up == 0)       e4y -= enem4Speed;    
           else if(en4up == 1)  e4y += enem4Speed;
           //Posicion actual enemigo 4
           int e4tx = e4x;int e4ty = e4y;
           
           // obtener posición enemigo 5
           int e5x = Enem5.getX();int e5y = Enem5.getY();
           // movimiento de enemigo 3 izquierda o derecha
           if(en5up == 0)       e5y -= enem5Speed;    
           else if(en5up == 1)  e5y += enem5Speed;
           //Posicion actual enemigo 5
           int e5tx = e5x;int e5ty = e5y;
           
           // obtener posición enemigo 6
           int e6x = Enem6.getX();int e6y = Enem6.getY();
           // movimiento de enemigo 6 izquierda o derecha
           if(en6up == 0)       e6y -= enem6Speed;    
           else if(en6up == 1)  e6y += enem6Speed;
           //Posicion actual enemigo 6
           int e6tx = e6x;int e6ty = e6y;
           
           // obtener posición enemigo 7
           int e7x = Enem7.getX();int e7y = Enem7.getY();
           // movimiento de enemigo 7 izquierda o derecha
           if(en7left == 1)       e7x -= enem7Speed;    
           else if(en7left == 0)  e7x += enem7Speed;
           //Posicion actual enemigo 7
           int e7tx = e7x;int e7ty = e7y;
           
           // obtener posición enemigo 8
           int e8x = Enem8.getX();int e8y = Enem8.getY();
           // movimiento de enemigo 8 izquierda o derecha
           if(en8left == 1)       e8x -= enem7Speed;    
           else if(en8left == 0)  e8x += enem7Speed;
           //Posicion actual enemigo 8
           int e8tx = e8x;int e8ty = e8y;
           
           // obtener posición enemigo 9
           int e9x = Enem9.getX();int e9y = Enem9.getY();
           // movimiento de enemigo 9 izquierda o derecha
           if(en9left == 1)       e9x -= enem9Speed;    
           else if(en9left == 0)  e9x += enem9Speed;
           //Posicion actual enemigo 9
           int e9tx = e9x;int e9ty = e9y;
           
           // obtener posición enemigo 10
           int e10x = Enem10.getX();int e10y = Enem10.getY();
           // movimiento de enemigo 10 izquierda o derecha
           if(en10left == 1)       e10x -= enem10Speed;    
           else if(en10left == 0)  e10x += enem10Speed;
           //Posicion actual enemigo 10
           int e10tx = e10x;int e10ty = e10y;
           
           // obtener posición enemigo 11
           int e11x = Enem11.getX();int e11y = Enem11.getY();
           // movimiento de enemigo 11 izquierda o derecha
           if(en11left == 1)       e11x -= enem11Speed;    
           else if(en11left == 0)  e11x += enem11Speed;
           //Posicion actual enemigo 11
           int e11tx = e11x;int e11ty = e11y;
           
           // obtener posición enemigo 12
           int e12x = Enem12.getX();int e12y = Enem12.getY();
           // movimiento de enemigo 12 izquierda o derecha
           if(en12left == 1)       e12x -= enem12Speed;    
           else if(en12left == 0)  e12x += enem12Speed;
           //Posicion actual enemigo 12
           int e12tx = e12x;int e12ty = e12y;
           
               
           
           // obtener posición enemigo 13
           int e13x = Enem13.getX();int e13y = Enem13.getY();
           // movimiento de enemigo 13 izquierda o derecha
           if(en13up == 0)       e13y -= enem13Speed;    
           else if(en13up == 1)  e13y += enem13Speed;
           //Posicion actual enemigo 13
           int e13tx = e13x;int e13ty = e13y;
           
           // obtener posición enemigo 14
           int e14x = Enem14.getX();int e14y = Enem14.getY();
           // movimiento de enemigo 14 izquierda o derecha
           if(en14up == 0)       e14y -= enem14Speed;    
           else if(en14up == 1)  e14y += enem14Speed;
           //Posicion actual enemigo 14
           int e14tx = e14x;int e14ty = e14y;
           
           // obtener posición enemigo 15
           int e15x = Enem15.getX();int e15y = Enem15.getY();
           // movimiento de enemigo 15 izquierda o derecha
           if(en15up == 0)       e15y -= enem15Speed;    
           else if(en15up == 1)  e15y += enem15Speed;
           //Posicion actual enemigo 15
           int e15tx = e15x;int e15ty = e15y;
           
           // obtener posición enemigo 16
           int e16x = Enem16.getX();int e16y = Enem16.getY();
           // movimiento de enemigo 16 izquierda o derecha
           if(en16up == 0)       e16y -= enem16Speed;    
           else if(en16up == 1)  e16y += enem16Speed;
           //Posicion actual enemigo 16
           int e16tx = e16x;int e16ty = e16y;
           
           // obtener posición enemigo 17
           int e17x = Enem17.getX();int e17y = Enem17.getY();
           // movimiento de enemigo 17 izquierda o derecha
           if(en17up == 0)       e17y -= enem17Speed;    
           else if(en17up == 1)  e17y += enem17Speed;
           //Posicion actual enemigo 17
           int e17tx = e17x;int e17ty = e17y;
           
           // obtener posición enemigo 18
           int e18x = Enem18.getX();int e18y = Enem18.getY();
           // movimiento de enemigo 18 izquierda o derecha
           if(en18up == 0)       e18y -= enem18Speed;    
           else if(en18up == 1)  e18y += enem18Speed;
           //Posicion actual enemigo 18
           int e18tx = e18x;int e18ty = e18y;
           
           // obtener posición enemigo 19
           int e19x = Enem19.getX();int e19y = Enem19.getY();
           // movimiento de enemigo 19 izquierda o derecha
           if(en19up == 0)       e19y -= enem19Speed;    
           else if(en19up == 1)  e19y += enem19Speed;
           //Posicion actual enemigo 19
           int e19tx = e19x;int e19ty = e19y;
           
           
           // obtener posición enemigo 20
           int e20x = Enem20.getX();int e20y = Enem20.getY();
           // movimiento de enemigo 20 izquierda o derecha
           if(en20up == 0)       e20y -= enem20Speed;    
           else if(en20up == 1)  e20y += enem20Speed;
           //Posicion actual enemigo 20
           int e20tx = e20x;int e20ty = e20y;
//           
           // obtener posición enemigo 21
           int e21x = Enem21.getX();int e21y = Enem21.getY();
           // movimiento de enemigo 21 izquierda o derecha
           if(en21left == 1)       e21x -= enem21Speed;    
           else if(en21left == 0)  e21x += enem21Speed;
           //Posicion actual enemigo 21
           int e21tx = e21x;int e21ty = e21y;
           
           // obtener posición enemigo 22
           int e22x = Enem22.getX();int e22y = Enem22.getY();
           // movimiento de enemigo 22 izquierda o derecha
           if(en22left == 1)       e22x -= enem22Speed;    
           else if(en22left == 0)  e22x += enem22Speed;
           //Posicion actual enemigo 22
           int e22tx = e22x;int e22ty = e22y;
           
           // obtener posición enemigo 23
           int e23x = Enem23.getX();int e23y = Enem23.getY();
           // movimiento de enemigo 23 izquierda o derecha
           if(en23left == 1)       e23x -= enem23Speed;    
           else if(en23left == 0)  e23x += enem23Speed;
           //Posicion actual enemigo 23
           int e23tx = e23x;int e23ty = e23y; 
                   
                   
           
           /*****************************************/
           
           // guardar la posicion actual en variables temporales
           // para poder restaurarla cuando chocamos con un bloque
           int tx = cx;
           int ty = cy;   
                     
           // aqui se asignan las animaciones dependiendo del
           //sentido en que avance el personaje
           //UP - decrease the value of the Y coordinate
           //Down - increase the value of the Y coordinate
           //Left - decrease the value of the X coordinate
           //Right - increase the value of the X coordinate
           if ((iKey & GameCanvas.UP_PRESSED) != 0){
               if(up==0){
                   up=1;
                   down=0;
                   left=0;
                   right=0;
                   Heroe.setFrameSequence(sequence3);                   
               }
               Heroe.nextFrame();           
               cy -= vanSpeed;
               
           } else if ((iKey & GameCanvas.DOWN_PRESSED) != 0){
               if(down==0){
                   up=0;
                   down=1;
                   left=0;
                   right=0;
                   Heroe.setFrameSequence(sequence1);                   
               }
               Heroe.nextFrame();
               
               
               cy += vanSpeed;
               
           } else if ((iKey & GameCanvas.LEFT_PRESSED) != 0){
               if(left==0){
                   up=0;
                   down=0;
                   left=1;
                   right=0;
                   Heroe.setFrameSequence(sequence4);                   
               }
               Heroe.nextFrame();
               
               
               cx -= vanSpeed;
           } else if ((iKey & GameCanvas.RIGHT_PRESSED) != 0){
               if(right==0){
                   up=0;
                   down=0;
                   left=0;
                   right=1;
                   Heroe.setFrameSequence(sequence2);                   
               }
               
               if(cont%180==0){
               Heroe.nextFrame();
               }
               
               cx += vanSpeed;
                       
           }                   
           
                 
           // update the vans position
           Heroe.setPosition(cx, cy);
           //check if the van hits a block
           if ((Heroe.collidesWith(blockMap, true))||(Heroe.collidesWith(blockMap1, true))
                   ||(Heroe.collidesWith(blockMap2, true))){
             //reset the van to the original position  
             Heroe.setPosition(tx, ty);
           }
           
           /*************ENEMIGOS****************/
          // colision con enemigos
           if ((Heroe.collidesWith(Enem1, true)||Heroe.collidesWith(Enem2, true)
                   ||Heroe.collidesWith(Enem3, true)||Heroe.collidesWith(Enem4, true)
                   ||Heroe.collidesWith(Enem5, true)||Heroe.collidesWith(Enem6, true)
                   ||Heroe.collidesWith(Enem7, true)||Heroe.collidesWith(Enem8, true)
                   ||Heroe.collidesWith(Enem9, true)||Heroe.collidesWith(Enem10, true)
                   ||Heroe.collidesWith(Enem11, true)||Heroe.collidesWith(Enem12, true)
                   )&&(nivelActual==1))
                   {
             //reset the van to the original position  
             Heroe.setPosition(16, 16);
             up=0;
             down=0;
             left=0;
             right=0;
           }
           
           if ((Heroe.collidesWith(Enem13, true)||Heroe.collidesWith(Enem14, true)
              ||Heroe.collidesWith(Enem15, true)||Heroe.collidesWith(Enem16, true)
              ||Heroe.collidesWith(Enem17, true)||Heroe.collidesWith(Enem18, true)
              ||Heroe.collidesWith(Enem19, true)||Heroe.collidesWith(Enem20, true)
              ||Heroe.collidesWith(Enem21, true)||Heroe.collidesWith(Enem22, true)
              ||Heroe.collidesWith(Enem23, true)
                   )&&(nivelActual==2)){
               //reset the van to the original position  
             Heroe.setPosition(208, 16);
             up=0;
             down=0;
             left=0;
             right=0;
           }    
           
           
           // update the enem1 position
           Enem1.setPosition(e1x, e1y);
           //check if the Enem1 hits a block
           if (Enem1.collidesWith(blockMap, true)){
             //reset the van to the original position  
             Enem1.setPosition(e1tx, e1ty);
             if(en1left == 1){en1left=0;e1x += enem1Speed;}
             else if(en1left == 0){en1left=1;e1x -= enem1Speed;}
           }
           
           // update the enem2 position
           Enem2.setPosition(e2x, e2y);
           //check if the Enem2 hits a block
           if (Enem2.collidesWith(blockMap, true)){
             //reset the van to the original position  
             Enem2.setPosition(e2tx, e2ty);
             if(en2left == 1){en2left=0;e2x += enem2Speed;}
             else if(en2left == 0){en2left=1;e2x -= enem2Speed;}
           }
           // update the enem3 position
           Enem3.setPosition(e3x, e3y);
           //check if the Enem3 hits a block
           if (Enem3.collidesWith(blockMap, true)){
             //reset the van to the original position  
             Enem3.setPosition(e3tx, e3ty);
             if(en3up == 1){en3up=0;e3x -= enem3Speed;}
             else if(en3up == 0){en3up=1;e3x += enem3Speed;}
           }
           // update the enem4 position
           Enem4.setPosition(e4x, e4y);
           //check if the Enem4 hits a block
           if (Enem4.collidesWith(blockMap, true)){
             //reset the van to the original position  
             Enem4.setPosition(e4tx, e4ty);
             if(en4up == 1){en4up=0;e4x -= enem4Speed;}
             else if(en4up == 0){en4up=1;e4x += enem4Speed;}
           }
           
           // update the enem5 position
           Enem5.setPosition(e5x, e5y);
           //check if the Enem5 hits a block
           if (Enem5.collidesWith(blockMap, true)){
             //reset the van to the original position  
             Enem5.setPosition(e5tx, e5ty);
             if(en5up == 1){en5up=0;e5x -= enem5Speed;}
             else if(en5up == 0){en5up=1;e5x += enem5Speed;}
           }
           
           // update the enem6 position
           Enem6.setPosition(e6x, e6y);
           //check if the Enem6 hits a block
           if (Enem6.collidesWith(blockMap, true)){
             //reset the van to the original position  
             Enem6.setPosition(e6tx, e6ty);
             if(en6up == 1){en6up=0;e6x -= enem6Speed;}
             else if(en6up == 0){en6up=1;e6x += enem6Speed;}
           }
           
           // update the enem7 position
           Enem7.setPosition(e7x, e7y);
           //check if the Enem7 hits a block
           if (Enem7.collidesWith(blockMap, true)){
             //reset the van to the original position  
             Enem7.setPosition(e7tx, e7ty);
             if(en7left == 1){en7left=0;e7x += enem7Speed;}
             else if(en7left == 0){en7left=1;e7x -= enem7Speed;}
           }
           
           // update the enem8 position
           Enem8.setPosition(e8x, e8y);
           //check if the Enem8 hits a block
           if (Enem8.collidesWith(blockMap, true)){
             //reset the van to the original position  
             Enem8.setPosition(e8tx, e8ty);
             if(en8left == 1){en8left=0;e8x += enem8Speed;}
             else if(en8left == 0){en8left=1;e8x -= enem8Speed;}
           }
           
           // update the enem9 position
          Enem9.setPosition(e9x, e9y);
           //check if the Enem9 hits a block
           if (Enem9.collidesWith(blockMap, true)){
             //reset the van to the original position  
             Enem9.setPosition(e9tx, e9ty);
             if(en9left == 1){en9left=0;e9x += enem9Speed;}
             else if(en9left == 0){en9left=1;e9x -= enem9Speed;}
           }
           
           // update the enem10 position
           Enem10.setPosition(e10x, e10y);
           //check if the Enem10 hits a block
           if (Enem10.collidesWith(blockMap, true)){
             //reset the van to the original position  
             Enem10.setPosition(e10tx, e10ty);
             if(en10left == 1){en10left=0;e10x += enem10Speed;}
             else if(en10left == 0){en10left=1;e10x -= enem10Speed;}
            }
           
           // update the enem11 position
           Enem11.setPosition(e11x, e11y);
           //check if the Enem11 hits a block
           if (Enem11.collidesWith(blockMap, true)){
             //reset the van to the original position  
             Enem11.setPosition(e11tx, e11ty);
             if(en11left == 1){en11left=0;e11x += enem11Speed;}
             else if(en11left == 0){en11left=1;e11x -= enem11Speed;}
           }
           
            //update the enem12 position
           Enem12.setPosition(e12x, e12y);
          // check if the Enem12 hits a block
           if (Enem12.collidesWith(blockMap, true)){
            // reset the van to the original position  
             Enem12.setPosition(e12tx, e12ty);
             if(en12left == 1){en12left=0;e12x += enem12Speed;}
             else if(en12left == 0){en12left=1;e12x -= enem12Speed;}
           }
          
           
           // update the enem13 position
          Enem13.setPosition(e13x, e13y);
//           //check if the Enem13 hits a block
           if (Enem13.collidesWith(blockMap1, true)){
//             //reset the van to the original position  
             Enem13.setPosition(e13tx, e13ty);
             if(en13up == 1){en13up=0;e13y -= enem13Speed;}
             else if(en13up == 0){en13up=1;e13y += enem13Speed;}
           }
           
          // update the enem14 position
          Enem14.setPosition(e14x, e13y);
//           //check if the Enem14 hits a block
           if (Enem14.collidesWith(blockMap1, true)){
//             //reset the van to the original position  
             Enem14.setPosition(e14tx, e14ty);
             if(en14up == 1){en14up=0;e14y -= enem14Speed;}
             else if(en14up == 0){en14up=1;e14y += enem14Speed;}
           }
          
          // update the enem15 position
          Enem15.setPosition(e15x, e15y);
//           //check if the Enem15 hits a block
           if (Enem15.collidesWith(blockMap1, true)){
//             //reset the van to the original position  
             Enem15.setPosition(e15tx, e15ty);
             if(en15up == 1){en15up=0;e15y -= enem15Speed;}
             else if(en15up == 0){en15up=1;e15y += enem15Speed;}
           }
          
          // update the enem16 position
          Enem16.setPosition(e16x, e16y);
//           //check if the Enem16 hits a block
           if (Enem16.collidesWith(blockMap1, true)){
//             //reset the van to the original position  
             Enem16.setPosition(e16tx, e16ty);
             if(en16up == 1){en16up=0;e16y -= enem16Speed;}
             else if(en16up == 0){en16up=1;e16y += enem16Speed;}
           }
          
          // update the enem17 position
          Enem17.setPosition(e17x, e17y);
//           //check if the Enem17 hits a block
           if (Enem17.collidesWith(blockMap1, true)){
//             //reset the van to the original position  
             Enem17.setPosition(e17tx, e17ty);
             if(en17up == 1){en17up=0;e17y -= enem17Speed;}
             else if(en17up == 0){en17up=1;e17y += enem17Speed;}
           }
          
          // update the enem18 position
          Enem18.setPosition(e18x, e18y);
//           //check if the Enem18 hits a block
           if (Enem18.collidesWith(blockMap1, true)){
//             //reset the van to the original position  
             Enem18.setPosition(e18tx, e18ty);
             if(en18up == 1){en18up=0;e18y -= enem18Speed;}
             else if(en18up == 0){en18up=1;e18y += enem18Speed;}
           }
          
          // update the enem19 position
          Enem19.setPosition(e19x, e19y);
//           //check if the Enem19 hits a block
           if (Enem19.collidesWith(blockMap1, true)){
//             //reset the van to the original position  
             Enem19.setPosition(e19tx, e19ty);
             if(en19up == 1){en19up=0;e19y -= enem19Speed;}
             else if(en19up == 0){en19up=1;e19y += enem19Speed;}
           }
          
          // update the enem20 position
          Enem20.setPosition(e20x, e20y);
//           //check if the Enem20 hits a block
           if (Enem20.collidesWith(blockMap1, true)){
//             //reset the van to the original position  
             Enem20.setPosition(e20tx, e20ty);
             if(en20up == 1){en20up=0;e20y -= enem20Speed;}
             else if(en20up == 0){en20up=1;e20y += enem20Speed;}
           }
          
          // update the enem21 position
          Enem21.setPosition(e21x, e21y);
//           //check if the Enem21 hits a block
           if (Enem21.collidesWith(blockMap1, true)){
//             //reset the van to the original position  
             Enem21.setPosition(e21tx, e21ty);
             if(en21left == 1){en21left=0;e21x -= enem21Speed;}
             else if(en21left == 0){en21left=1;e21x += enem21Speed;}
           }
          
          // update the enem22 position
          Enem22.setPosition(e22x, e22y);
//           //check if the Enem22 hits a block
           if (Enem22.collidesWith(blockMap1, true)){
//             //reset the van to the original position  
             Enem22.setPosition(e22tx, e22ty);
             if(en22left == 1){en22left=0;e22x -= enem22Speed;}
             else if(en22left == 0){en22left=1;e22x += enem22Speed;}
           }
          
          // update the enem23 position
          Enem23.setPosition(e23x, e23y);
//           //check if the Enem23 hits a block
           if (Enem23.collidesWith(blockMap1, true)){
//             //reset the van to the original position  
             Enem23.setPosition(e23tx, e23ty);
             if(en23left == 1){en23left=0;e23x -= enem23Speed;}
             else if(en23left == 0){en23left=1;e23x += enem23Speed;}
           }
           
            /***************************************/
           
           // Cambio de nivel al llegar a salida del nivel actual
           if((cx>200)&&(cy>280)){
               up=0;
               down=0;
               left=0;
               right=0;
               
               unload();
               nivelActual++;
               load(nivelActual);
               if(nivelActual==2)
               Heroe.setPosition(208, 16);
               else Heroe.setPosition(16, 16);
               g = getGraphics();
               }
           
           
           //restaurar el clipping rectangle a pantalla completa
           g.setClip(0, 0, screenW, screenH);
           //dibujar el camino
           roadMap.paint(g);
           
           //Dibujar los bloques
           if(nivelActual==1)
           blockMap.paint(g);
           else if(nivelActual==2)
           blockMap1.paint(g);
           else if(nivelActual==3)
           blockMap2.paint(g);
           
           // dibujar sprites
           Heroe.paint(g);
           /*************ENEMIGOS***********/
           if(nivelActual==1){
           Enem1.paint(g);
           Enem2.paint(g);
           Enem3.paint(g);
           Enem4.paint(g);
           Enem5.paint(g);
           Enem6.paint(g);
           Enem7.paint(g);
           Enem8.paint(g);
           Enem9.paint(g);
           Enem10.paint(g);
           Enem11.paint(g);
           Enem12.paint(g);
           }
           else if(nivelActual==2){
               Enem13.paint(g);
               Enem14.paint(g);
               Enem15.paint(g);
               Enem16.paint(g);
               Enem17.paint(g);
               Enem18.paint(g);
               Enem19.paint(g);
               Enem20.paint(g);
               Enem21.paint(g);
               Enem22.paint(g);
               Enem23.paint(g);
           }
           /********************************/
           
          
           //al final del loop flushGraphics() dibuja lo que se desea
           //ver por pantalla
           flushGraphics();
           
           try{
        	   //el thread se duerme 30 ms y luego continua
               Thread.sleep(30);
           } catch (Exception ex){
               
           }
       }
       g = null;
       unload();
       fParent.destroyApp(false);
       fParent = null;
       cont++;
    }
}  
    

