//Controls class
public class Controles implements KeyListener {
   protected Applet padre;
   protected String direccion;
         
   public Controles(Applet a){
      direccion = "";
      a.addKeyListener(this);
   }
      
   public void keyTyped(KeyEvent e){}
   public void keyPressed(KeyEvent e) {
      int id = e.getKeyCode();
      switch(id){
         case KeyEvent.VK_UP:
            direccion = "Ar";
            break;
            
         case KeyEvent.VK_DOWN: 
            direccion = "Ab";
            break;
         
         case KeyEvent.VK_LEFT: 
            direccion = "Iz";
            break;
         
         case KeyEvent.VK_RIGHT: 
            direccion = "De";
            break;
      }
   }
   public void keyReleased(KeyEvent e) {
      direccion = "";
   }
   
   //Enviar la direccion de las teclas:
   public String getDireccion(){
      return direccion;
   }
   
}

public void movimientoGrid(String b){
      b = controls.getDireccion();
                switch(b){
      case "Ar":
         for(int i=0; i<mosagrid.size(); i++){
            mosagrid.get(i).posY += velocidad;
            mosagrid.get(i).paint(pintor);
         }
         break;
      case "Ab":
         for(int i=0; i<mosagrid.size(); i++){
            mosagrid.get(i).posY -= velocidad;
            mosagrid.get(i).paint(pintor);
         }
         break;
      case "Iz":
         for(int i=0; i<mosagrid.size(); i++){
            mosagrid.get(i).posX += velocidad;
            mosagrid.get(i).paint(pintor);
         }
         break;
      case "De":
         for(int i=0; i<mosagrid.size(); i++){
            mosagrid.get(i).posX -= velocidad;
            mosagrid.get(i).paint(pintor);
         }
         break;
      }
   }

//Create a blank transparent buffered image:
BufferedImage grid = new BufferedImage(800, 600, BufferedImage.TRANSLUCENT);
Graphics2D pintor = grid.createGraphics();

//transfer a single prototipe tile on to  my bufferedimage
prototipo.paint(pintor);

//painting it
public void printMapa(Graphics2D g){
   Rectangle2D.Double rect = new Rectangle2D.Double(0, 0, pantancho, pantalto);
   pintor.setComposite(AlphaComposite.getInstance(AlphaComposite.CLEAR, 0.0f));
   pintor.fill(rect);
        g.drawImage(grid, 0, 0, padre);
        pintor = grid.createGraphics();
}

public pruebaGM(int ancho, int alto, int mosx, int mosy, int a[][], Applet p){
      
      //Applet padre
      padre = p;
      
      //Medidas del padre
      pantancho = ancho;
      pantalto = alto;
      
      //Creacion de mosaico modelo
      prototipo = new Mosaico(0, p);
      
      //Medidas de mosaico modelo
      mosancho = prototipo.ancho;
      mosalto = prototipo.alto;
      
      //Mitad de las medidas para puntos de referencia
      mosanchoMT = (mosancho/2)-1;
      mosaltoMT = mosalto/2;
      
      //Mosaicos visibles segun tamano de la pantalla
      mosavis = Math.round(pantancho*2/mosancho);
      //mosavisy = Math.round((pantalto*2)/mosaltoMT);
      
      //Referencia para centralizar mapa
      offsetH = Math.round(pantancho/2-mosanchoMT);
      //offsetV = Math.round((pantalto-(mosavisy*mosalto))/2);
      
      //Mitad de los mosaicos visibles
      mosavisMT = Math.round(mosavis/2);
      //mosavisyMT = Math.round(mosavisy/2);
      
      //Mosaicos de definicion de boundaries
      mosaX1 = mosx-mosavisMT;
      mosaX2 = mosx+mosavisMT;
      mosaY1 = mosy-mosavisMT;
      mosaY2 = mosy+mosavisMT;
      
      //Lienzo donde sera plasmado el mapa
      grid = new BufferedImage(ancho, alto, BufferedImage.TRANSLUCENT);
      
      //Creando interfaz grafica
      pintor = grid.createGraphics();
      
      //Buffer para registro de mosaico visible
      mosanum = 0;
      
      System.out.println("Eje de X: "+mosaX1+"-"+mosaX2);
      System.out.println("Eje de Y: "+mosaY1+"-"+mosaY2);
      //Bucle de construccion
      for(int i=mosaX1; i<mosaX2; i++){
         for(int j=mosaY1; j<mosaY2; j++){
            try{
               System.out.println(i);
               mosagrid = new Mosaico[mosavis*2];
               mosagrid[mosanum] = new Mosaico(a[i][j], p);
               mosagrid[mosanum].posX = ((j*mosanchoMT)-(i*mosanchoMT))+offsetH;
               mosagrid[mosanum].posY = ((j*mosaltoMT)+(i*mosaltoMT));//+offsetV;
               mosagrid[mosanum].paint(pintor);
               mosanum++;
            }catch(Exception ex){}
         }
      }
   }

import java.applet.*;
import java.awt.*;
import java.awt.image.*;

public class Prueba extends Applet implements Runnable{
   //Declaracion de variables
   int i;
   BufferedImage backBuffer;
   Graphics2D painter;
   Thread t;
   int movilidadX;
   int movilidadY;
   
   //Metodos de clase
   public void init(){
      t = new Thread(this);
      backBuffer = new BufferedImage(600, 400, BufferedImage.TYPE_INT_RGB);
      painter = backBuffer.createGraphics();
      i = 0;
      movilidadX = 0;
      movilidadY = 0;
      t.start();
   }
   public void run(){
      while(true){
         i++;
         movilidadX++;
         movilidadY++;
         repaint();
         try{
            t.sleep(1000/30);
         }catch(InterruptedException ex){
            ex.printStackTrace();
         }
      }
   }
   public void paint(Graphics g){
      painter.setColor(Color.GRAY);
      painter.fillRect(0, 0, 600, 400);
      painter.setColor(Color.BLACK);
      painter.fillRect(movilidadX, movilidadY, 10, 10);
      painter.drawString("El valor de i es: " + i, 20, 20);
      g.drawImage(backBuffer, 0, 0, this);
      paint(g);
   }
}

import java.applet.*;
import java.awt.*;

public class Prueba extends Applet implements Runnable{
   Thread t;
   int i;
   Graphics backBufferG;
   Image backBufferI;
            
   public void init(){
     t = new Thread(this);
      t.start();
      i = 0;
      backBufferI = createImage(600, 600);
      backBufferG = backBufferI.getGraphics();
      
   }
   public void run(){
      while(true){
         i++;
         repaint();
         try{
            t.sleep(1000/29);
         }catch(Exception ex){;}   
      }
   }
   public void paint(Graphics g){
     backBufferG.drawString("i = "+i, 10, 20);
      g.drawImage(backBufferI, 0, 0, this);
   }
   public void update(Graphics g){
      paint(g);
   }
}

import java.applet.*;
import java.awt.*;

public class Prueba extends Applet implements Runnable{
   Thread t;
   int i;
   Graphics backBufferG;
   Image backBufferI;
   Dimension Dim;
         
   public void init(){
      t = new Thread(this);
      t.start();
      i = 0;
      Dim.getSize();
      backBufferI = createImage(600, 600);
      backBufferG = backBufferI.getGraphics();
      
   }
   public void run(){
      while(true){
         i++;
         repaint();
         try{
            t.sleep(1000/30);
         }catch(Exception ex){;}   
      }
   }
   public void paint(Graphics g){
      backBufferG.drawString("i = "+i, 10, 20);
      g.drawImage(backBufferI, 0, 0, this);
   }
}

import java.applet.*;
import java.awt.*;
import java.awt.event.*;

public class Prueba extends Applet implements Runnable, KeyListener{
   String message;
   Thread t;
   int i;
   
   public void init(){
      addKeyListener(this);
      t = new Thread(this);
      t.start();
      
      i = 0;
   }
   
   public void run(){
      while(true){
         i++;
         repaint();
         
         try{
            t.sleep(1000/30);
         }catch(Exception ex){;}   
      }
   }
   public void paint(Graphics g){
      g.drawString("i = "+i, 10, 20);
      g.drawString(message, 50, 80);
   }
   public void keyPressed(KeyEvent e) {
        message = "KEY PRESSED: " + e;
    }
   public void keyTyped(KeyEvent e) {;}
   public void keyReleased(KeyEvent e) {;}
}