import java.awt.*;

import javax.swing.*;



import java.awt.event.*;
import java.io.*;
import java.util.Random;
import java.util.Vector;
import java.net.URL;
import javax.imageio.ImageIO;
import java.lang.Math;

//import com.sun.image.codec.jpeg.JPEGCodec;
//import com.sun.image.codec.jpeg.JPEGImageDecoder;
import java.awt.image.BufferedImage;
	//he trabajado con el frame para poder utilizar la opcion de cerrar la ventana
@SuppressWarnings({ "serial", "unused" })

public class ZorraGansos extends Frame implements  MouseListener, ActionListener,ItemListener
{
     
    BufferedImage buffer;
    
    public static Color colorFondo1;
    public static Color colorFondo2;
    
    public static boolean dosColores = true;

    MenuBar mBarra;
    
    Menu mJuego;
    Menu mEstad;
    Menu mColor;
    //Menu mJugadores; 
    Menu mAspecto;
    Menu mAyuda; 
    Menu mTotalMov;
    Menu mAcerca;
    
    MenuItem mNueva;
    MenuItem mComo;
    MenuItem mEstadisticas;
    MenuItem mSalir;
    MenuItem mAcerca1;
    
    CheckboxMenuItem  mColor1;
    CheckboxMenuItem  mColor2;
    CheckboxMenuItem  mColor3;
    CheckboxMenuItem  mColor4;
    CheckboxMenuItem  mColor5;
    CheckboxMenuItem  mColor6;
    CheckboxMenuItem  mTotalMov1;
    CheckboxMenuItem  mTotalMov2;
    CheckboxMenuItem  mTotalMov3;
    CheckboxMenuItem  mTotalMov4;
        
    public static Label lInfoJug1 = new Label("Jugador: Gansos", 1);
    public static Label lInfoJug2 = new Label("Jugador: Zorra", 1);
    public static Label lTiempo = new Label("Tiempo Transcurrido", 1);
    public static Label lAviso  = new Label(" ", 1);
    public static Label lTurno  = new Label(" ", 1);
    
    //////////////////////////////////////////////////////////////////////////////////////////
    /*
     * Para poner un cuadro con el número de movimientos. 
     * 
     * Quizas se quite, pero es interesante para las pruebas.
     */
    
    public static Label lNumMovimientos = new Label("Numero de Movimientos", 1);
    
    //////////////////////////////////////////////////////////////////////////////////////////
    
    public static JButton botonJugador1;
    public static JButton botonJugador2;
    
    Panel panel1, panel2, panel3, panel4;
    
    public static ImageIcon USjug1, USjug2, USjug3, USjug4, PCjug1,PCjug2, PCjug3, PCjug4, NOjug;
    
    public static Tablero tablero;
    
    //////////////////////////////////////////////////////////////////////////////////
    //tablero para minimax para que no machaque el que tengo
    
    public static Tablero auxtablero;
    
    //////////////////////////////////////////////////////////////////////////////////
    
    public static int numjugadores = 2; //Por defecto 2 jugadores
    
    //////////////////////////////////////////////////////////////////////
    // PARA ELEGIR EL TIPO DE TABLERO A USAR.
    // TIPO 1: 5X5. 
    // TIPO 2: 7X7
    // TIPO 3: CRUZ
    /////////////////////////////////////////////////////////////////////
    
    public static int tipotabl = 1;

    //////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////
    
    String ruta;
    public Opciones opciones;
    
    public static int turno = 1; // Por defecto sale el jugador 1. turno 1 equivale a jugador 1
    public static boolean detenerJuego = false;
    
    
    //public static int totalMovimientos = 30;
    public static int totalMovimientos = 30;
    
    public static Tiempo tiempo=new Tiempo();
    
    public static int saltos[]={-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1}; //Consideramos maximo 16 saltos
    public boolean flagSalto = false;
    public int numsalto = 0; //Para saber porque salto vamos
    
    int seleccionada_posi = -1; //Guarda el indice i de la posicion seleccionada. Antes era marcado[0]
 	int seleccionada_posj = -1; //Guarda el indice j de la posicion seleccionada. Antes era marcado [1]
    int candidata_posi = -1; //Guarda el indice i de la posicion candidata. Antes era flagMarcado[0]
    int candidata_posj = -1; //Guarda el indice j de la posicion candidata. Antes era flagMarcado[1]
    
    boolean flag = false;
    int cuentaEmpezar=0;
    static String NombreArchivo = "";
    public Sucesor elegido;
    public Sucesores actual;
    
    public MiniMax minimax;
    
    public int numMovimientos= 0;
    
    ///////////////////////////////////////////////
    public static int sal_borra[]={-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
    public int nfiblan = 0;
    
    public static int vector_aux[]={-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
    
    public int elimina = 0; //para el mover_pc, cuando la zorra se come un patito.
    
    public int NumFicPat = 12;
    
    ///////////////////////////////////////////////
    
    public int contador = 0;
    public int contador1 = 0;
    public int contador2 = 0;
    public Sucesor repetido = new Sucesor();
    public Sucesor repetido1 = new Sucesor();
    public Sucesor repetido2 = new Sucesor();
    
   public ZorraGansos(String s) 
   {
      	super(s);
        //setBounds(200, 30, 860, 720);
      	//setBounds(200, 30, 630, 720);
        setBounds(100, 0, 850, 568);
        
        
        buffer = new BufferedImage(getWidth(), getHeight(), 1);
        mBarra = new MenuBar();
        mJuego = new Menu("InicioJuego");
        mEstad = new Menu("Estadísticas");
        mNueva = new MenuItem(" Partida Nueva");
        mEstadisticas = new MenuItem("Mostrar Estadísticas");
        mTotalMov = new Menu("Criterio de parada");
       mAspecto = new Menu("Ajustes");
        mColor = new Menu("Color de fondo");
        mSalir = new MenuItem(" Salir");
        mAyuda = new Menu("Ayuda");
        mAcerca1 = new MenuItem("Acerca de Zorra y Gansos");
        //mAcerca = new Menu("Acerca de Zorra y Gansos");
        mAcerca = new Menu("Acerca?");

        mComo = new MenuItem(" Cómo Jugar");
         
        mColor1 = new CheckboxMenuItem("Color Rojo");
        mColor2 = new CheckboxMenuItem("Color Azul");
        mColor3 = new CheckboxMenuItem("Color Amarillo");
        mColor4 = new CheckboxMenuItem("Color Verde");
        mColor5 = new CheckboxMenuItem("Color Gris");
        mColor6 = new CheckboxMenuItem("... Predeterminado");
        
        mTotalMov1 = new CheckboxMenuItem("10 movimientos ");
        mTotalMov2 = new CheckboxMenuItem("20 movimientos ");
        mTotalMov3 = new CheckboxMenuItem("30 movimientos ");
        mTotalMov4 = new CheckboxMenuItem("Sin parada ");
        
        panel1 =new Panel(new GridLayout(0,1));
        panel2 =new Panel(new GridLayout(0,1));

        botonJugador1=new JButton();
        botonJugador2=new JButton();
        
        //Cargamos la direccion de las imagenes, que seran constantes
        USjug1=new ImageIcon(getClass().getResource("Images/USjug1.jpg"));
        USjug2=new ImageIcon(getClass().getResource("Images/USjug2.jpg"));

        PCjug1=new ImageIcon(getClass().getResource("Images/PCjug1.jpg"));
        PCjug2=new ImageIcon(getClass().getResource("Images/PCjug2.jpg"));

        Color c = new Color(221,221,221);
 	    Color PaleGreen = new Color(152,251,152); //98fb98
       
        colorFondo1 = PaleGreen;
        colorFondo2 = c;
        
        
        setMenuBar(mBarra);	
        
        mBarra.add(mJuego);	
        
        mJuego.add(mNueva);
        mJuego.addSeparator(); 
        mJuego.add(mSalir); 
        
        mBarra.add(mEstad);
        mEstad.add(mEstadisticas);
       
        mBarra.add(mAspecto); 
        mAspecto.add(mColor);
        mColor.add(mColor1);
        mColor.add(mColor2);
        mColor.add(mColor3);
        mColor.add(mColor4);
        mColor.add(mColor5);
        mColor.add(mColor6);
        
        mAspecto.addSeparator();
        mAspecto.add(mTotalMov);
        
        mTotalMov.add(mTotalMov1);
        mTotalMov.add(mTotalMov2);
        mTotalMov.add(mTotalMov3);
        mTotalMov.add(mTotalMov4);
        
        mBarra.add(mAyuda);
        //mAyuda.add(mAcerca);
        mAyuda.add(mComo);
        mBarra.add(mAcerca);
        mAcerca.add(mAcerca1);
        
        //lInfoJug1.setBounds(675,70, getWidth() - 675, 30);
        //lInfoJug1.setBounds(20,100, getWidth() - 700, 30);
        //lInfoJug1.setBounds(20,100, getWidth() - 470, 30);
        lInfoJug1.setBounds(20,70, getWidth() - 670, 30);
        lInfoJug1.setBackground(new Color(150, 150, 150));
        lInfoJug1.setForeground(Color.black);
        lInfoJug1.setFont(new Font("Times New Roman", 3, 14));
        add(lInfoJug1);
        
       // lInfoJug2.setBounds(675,200, getWidth() - 700, 30);
        //lInfoJug2.setBounds(675,300, getWidth() - 700, 30);
        //lInfoJug2.setBounds(20,400, getWidth() - 700, 30);
        //lInfoJug2.setBounds(20,400, getWidth() - 470, 30);
        lInfoJug2.setBounds(20,240, getWidth() - 670, 30);//PARA PORTATIL
        lInfoJug2.setBackground(new Color(150, 150, 150));
        lInfoJug2.setForeground(Color.black);
        lInfoJug2.setFont(new Font("Times New Roman", 3, 14));
        add(lInfoJug2);
       
        //lTiempo.setBounds(675,670, getWidth() - 700, 30);
        //lTiempo.setBounds(20,300, getWidth() - 700, 30);
        //lTiempo.setBounds(20,300, getWidth() - 470, 30);
        lTiempo.setBounds(20,190, getWidth() - 670, 30); //Para Portatil
        lTiempo.setForeground(Color.BLACK);
        lTiempo.setFont(new Font("Times New Roman", 5, 14));
        add(lTiempo);
        
        //lAviso.setBounds(20,691, getWidth() - 300+80, 26);
        //lAviso.setBounds(200,691, getWidth() - 300+50, 26);
        //lAviso.setBounds(200,691, getWidth() - 70+50, 26);
        //lAviso.setBounds(20,690, getWidth() - 70, 26);
        lAviso.setBounds(20,532, getWidth() - 70, 26);//PORTATIL
        //lAviso.setBackground(new Color( 57, 138, 138));
        lAviso.setBackground(new Color( 150, 150, 150));
        lAviso.setForeground(Color.BLACK);
        lAviso.setFont(new Font("Times New Roman", 3, 14));
        add(lAviso);
        
        //lTurno.setBounds(675,330, getWidth() - 700, 50);
        //lTurno.setBounds(675,230, getWidth() - 700, 50);
        //lTurno.setBounds(20,550, getWidth() - 700, 50);
        //lTurno.setBounds(20,550, getWidth() - 470, 50);
        lTurno.setBounds(20,360, getWidth() - 670, 50);//PROTATIL
        //lTurno.setBackground(new Color( 57, 138, 138));
        lTurno.setBackground(new Color( 150, 150, 150));
        lTurno.setForeground(Color.BLACK);
        lTurno.setFont(new Font("Times New Roman", 3, 18));
        add(lTurno);
        lTurno.setText("Turno: Jugador "+turno); //Para saber quien tiene el turno de mover
        
        ////////////////////////////////////////////////////////////////////////////////////////////////
        /*
         * Para el numero de movimientos
         */
        lNumMovimientos.setBounds(20,430, getWidth() - 670, 30); //Para Portatil
        lNumMovimientos.setForeground(Color.BLACK);
        lNumMovimientos.setFont(new Font("Times New Roman", 5, 14));
        add(lNumMovimientos);
        
        ////////////////////////////////////////////////////////////////////////////////////////////////
        
        //panel1.setBounds(675,100, getWidth() - 700,70);
        //panel1.setBounds(20,130, getWidth() - 700,70);
        //panel1.setBounds(20,130, getWidth() - 470,70);
        panel1.setBounds(20,100, getWidth() - 670,70);//PORTATIL
        panel1.add(botonJugador1);
        add(panel1);
        
        //panel2.setBounds(675,230, getWidth() - 700,70);
        //panel2.setBounds(675,330, getWidth() - 700,70);
        //panel2.setBounds(20,430, getWidth() - 700,70);
        //panel2.setBounds(20,430, getWidth() - 470,70);
        panel2.setBounds(20,270, getWidth() - 670,70);//PORTATIL
        panel2.add(botonJugador2);
        add(panel2);

        botonJugador1.setIcon(USjug1); 
        botonJugador2.setIcon(USjug2); 
        
        mColor.addActionListener(this); 
        mNueva.addActionListener(this);
        
        botonJugador1.addActionListener(this);
        botonJugador2.addActionListener(this);

        mAcerca.addActionListener(this);
        mEstadisticas.addActionListener(this);
        mComo.addActionListener(this);
        
        mColor1.addItemListener(this);
        mColor2.addItemListener(this);
        mColor3.addItemListener(this); 
        mColor4.addItemListener(this);
        mColor5.addItemListener(this);
        mColor6.addItemListener(this);
      
        mTotalMov.addActionListener(this);
        mTotalMov1.addItemListener(this);
        mTotalMov2.addItemListener(this);
        mTotalMov3.addItemListener(this);
        mTotalMov4.addItemListener(this);
        
        mSalir.addActionListener(this);
        mColor6.setState(true); 
        mTotalMov3.setState(true);
        ruta = "Piezas/";
     
        //tablero = new Tablero(numjugadores); //inicializo y dibuja el tablero inicial
        tablero = new Tablero(tipotabl);
        new Cinco(); //cargamos los estaticos (adyacentes y distancias de las casillas)
//////////////////////////////////////////////////////////////////////////////
        new SieteX();
        new Cruz();
        new Cinco_restri();
        new SieteX_restri();
        new Cruz_restri();
        
        
        tablero.jugadores[0].esPC = false; //decimos que jugador1 lo maneja por defecto el usuario
        tablero.jugadores[1].esPC = false; //decimos que jugador2 lo maneja por defecto el usuario
        //tablero.jugadores[1].esPC = true;
        //ESTO TA ASÏ PARA LA PRUEBA DE LA ZORRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
        
        nfiblan=tablero.jugadores[0].numFichaTotal;
        NumFicPat=tablero.jugadores[0].numFichaTotal;
        //System.out.println("Numero de patos: " + NumFicPat);
        
        
        lAviso.setText("Inicio Juego (Usuarios manejados por Usuario)");
        addMouseListener(this);
        
        actualizaPanelTurnos(); //Para que resalte el panelInfo del jugador que posee el turno
        
        setLayout(null);
        setResizable(false);
        addWindowListener( 
        		new WindowAdapter()
		        {
		        	public void windowClosing(WindowEvent e)
		        	{
		        		System.exit(0); //Esto hay que arreglarlo para preguntar antes de salir
		           	}
		        }
        		);
        
        addMouseMotionListener(
        		new MouseMotionAdapter() 
        		{
		            public void mouseMoved(MouseEvent me)
		            {
		                int i = me.getX();
		                int j = me.getY();
		            	
		                if (tipotabl == 1)
		                {
		                	if(i <= 270 || i >= 720 || j <=50 || j >= 500)
			            		setCursor(Cursor.getDefaultCursor());
			            	else	
			            		setCursor(Cursor.getPredefinedCursor(12));
		                }
		                if (tipotabl == 2)
		                {
		                	if(i <= 200 + 84 || i >= 662 + 84 || j <=50 || j >= 512)
			            		setCursor(Cursor.getDefaultCursor());
			            	else	
			            		setCursor(Cursor.getPredefinedCursor(12));
		                }
		                if (tipotabl == 3)
		                {
		                	if(i <= 200 + 84 || i >= 662 + 84 || j <=50 || j >= 512)
			            		setCursor(Cursor.getDefaultCursor());
			            	else	
			            		setCursor(Cursor.getPredefinedCursor(12));
		                }
		                if (tipotabl == 4)
		                {
		                	if(i <= 270 || i >= 720 || j <=50 || j >= 500)
			            		setCursor(Cursor.getDefaultCursor());
			            	else	
			            		setCursor(Cursor.getPredefinedCursor(12));
		                	
		                }
		                if (tipotabl == 5)
		                {
		                	if(i <= 200 + 84 || i >= 662 + 84 || j <=50 || j >= 512)
			            		setCursor(Cursor.getDefaultCursor());
			            	else	
			            		setCursor(Cursor.getPredefinedCursor(12));
		                
		                }
		                if (tipotabl == 6)
		                {
		                	if(i <= 270 + 84 || i >= 720 + 84 || j <=50 || j >= 512)
			            		setCursor(Cursor.getDefaultCursor());
			            	else	
			            		setCursor(Cursor.getPredefinedCursor(12));
		                	
		                }
		            }
        		}
        		);
        
        setVisible(true);
   }
   
   
   public void cerrar(String ma)
   {
   		Opciones tem= new Opciones(this);
   		tem.mostrar(ma);
   		System.exit(0);
   }
    
   public void paint(Graphics g) 
   {
	  Color c = new Color(221,221,221);
	   
	  Color PaleGreen = new Color(152,251,152); //98fb98
      Graphics2D graphics2d = (Graphics2D)buffer.getGraphics();
      
      graphics2d.clearRect(0, 0, buffer.getWidth(), buffer.getHeight());
      
      graphics2d.setPaint(new GradientPaint(0.0F, getHeight(), colorFondo1, getWidth(), 20F, colorFondo2, true));
           //fondo1 es el fondo de abajo a la izquierda  \y el otro de arriba a la dercha se pinta asi \
      graphics2d.fillRect(0, 0, getWidth(), getHeight());
        
      if (tipotabl == 1)
      {
    	  for (int j = 0; j < 5; j++)
	      {	
	    	  for (int i = 0; i < 5; i++)
	    	  {
	    		  	if(tablero.casillas[asociaCasilla(i,j)].numjugador == 1)
		          	{
		            		pintarPieza(1, j, i, false);
		          	}
		            else 
		            	if(tablero.casillas[asociaCasilla(i,j)].numjugador == 2)
			            {			
			            		pintarPieza(2, j, i, false);
			            }
	             	    else
			            {
			            	borrarCuadro(i, j); //Si no hay piezas que colocar, 
			            						//borrarCuadro lo que hace es dibujar la casilla (sin ficha)
			            }
	           }	
	      }
	     
      }
      
      
      if (tipotabl == 2)
      {
    	for (int j = 0; j < 7; j++)
	      {	
	    	   for (int i = 0; i < 7; i++)
	    	  {
	    		  	if(tablero.casillas[XasociaCasilla(i,j)].numjugador == 1)
		          	{
		            		pintarPieza(1, j, i, false);
		          	}
		            else 
		            	if(tablero.casillas[XasociaCasilla(i,j)].numjugador == 2)
			            {			
			            		pintarPieza(2, j, i, false);
			            }
	             	    else
			            {
			            	borrarCuadro(i, j); //Si no hay piezas que colocar, 
			            						//borrarCuadro lo que hace es dibujar la casilla (sin ficha)
			            }
	           }	
	      }
	      
      }
      if (tipotabl == 3)
      {
    	  for (int j = 0; j < 7; j++)
	      {	
	    	  for (int i = 0; i < 7; i++)
	    	  {
	    		  //if (((j > 1 || j < 5) && (i > 1 || j < 5)) 
	    		  if (((i > 1 || j < 5)) &&	  
	    			  ((i > 1 || j > 1)) &&	  
	    			  ((i < 5 || j < 5)) &&	  
	    			  ((i < 5 || j > 1))
	    			  )
	    		  {
		    		  if(tablero.casillas[XasociaCasilla(i,j)].numjugador == 1)
			          {
			            	pintarPieza(1, j, i, false);
			          }
			          else 
			            if(tablero.casillas[XasociaCasilla(i,j)].numjugador == 2)
				        {			
				            	pintarPieza(2, j, i, false);
				        }
		             	else
				        {
		             		borrarCuadro(i, j); //Si no hay piezas que colocar, 
				            						//borrarCuadro lo que hace es dibujar la casilla (sin ficha)
				        }
	    		  }
	    		}	
	      }
	        
      }
      if (tipotabl == 4)
      {
    	  for (int j = 0; j < 5; j++)
	      {	
	    	  for (int i = 0; i < 5; i++)
	    	  {
	    		  	if(tablero.casillas[asociaCasilla(i,j)].numjugador == 1)
		          	{
		            		pintarPieza(1, j, i, false);
		          	}
		            else 
		            	if(tablero.casillas[asociaCasilla(i,j)].numjugador == 2)
			            {			
			            		pintarPieza(2, j, i, false);
			            }
	             	    else
			            {
			            	borrarCuadro(i, j); //Si no hay piezas que colocar, 
			            						//borrarCuadro lo que hace es dibujar la casilla (sin ficha)
			            }
	           }	
	      }

      }
      if (tipotabl == 6)
      {
    	for (int j = 0; j < 7; j++)
	      {	
	    	  for (int i = 0; i < 7; i++)
	    	  {
	    		  	if(tablero.casillas[XasociaCasilla(i,j)].numjugador == 1)
		          	{
		            		pintarPieza(1, j, i, false);
		          	}
		            else 
		            	if(tablero.casillas[XasociaCasilla(i,j)].numjugador == 2)
			            {			
			            		pintarPieza(2, j, i, false);
			            }
	             	    else
			            {
			            	borrarCuadro(i, j); //Si no hay piezas que colocar, 
			            						//borrarCuadro lo que hace es dibujar la casilla (sin ficha)
			            }
	           }	
	      }
	      
      }
      if (tipotabl == 5)
      {
    	//   for(int j = 0; j < 16; j++)
	      for (int j = 0; j < 7; j++)
	      {	
	    	  //for(int i = 0; i < 16; i++)
	    	  for (int i = 0; i < 7; i++)
	    	  {
	    		  //if (((j > 1 || j < 5) && (i > 1 || j < 5)) 
	    		  if (((i > 1 || j < 5)) &&	  
	    			  ((i > 1 || j > 1)) &&	  
	    			  ((i < 5 || j < 5)) &&	  
	    			  ((i < 5 || j > 1))
	    			  )
	    		  {
	    		  	if(tablero.casillas[XasociaCasilla(i,j)].numjugador == 1)
		          	{
		            		pintarPieza(1, j, i, false);
		          	}
		            else 
		            	if(tablero.casillas[XasociaCasilla(i,j)].numjugador == 2)
			            {			
			            		pintarPieza(2, j, i, false);
			            }
	             	    else
			            {
			            	borrarCuadro(i, j); //Si no hay piezas que colocar, 
			            						//borrarCuadro lo que hace es dibujar la casilla (sin ficha)
			            }
	    		  }
	           }	
	      }
	       
      }
     
      
      g.drawImage(buffer, 0, 0, this);
//nota: las coordenadas se toman empezando el extremo superior izquierdo de la ventana
   }
 
//borrarCuadro dibuja la casilla de la posicion i,j sin nada (solo la celda, sin ficha)
   public void borrarCuadro(int x, int y)
   {
	   Graphics2D graphics2d = (Graphics2D)buffer.getGraphics();
	   //////
	      Image imagenFicha;
	      String name="";
	   if (tipotabl == 1 || tipotabl == 4)
	   {
		   
		      
		      
	 //Con el clearRect es como si te repintara los limites de cada rectangulo
	       //graphics2d.clearRect(80 * x+20, 80* y+50 , 80, 80);
		   graphics2d.clearRect(70 * x+270+25*x, 70* y+50+25*y , 70, 70);
		   
	       if(y % 2 != 0)
	       {
	    	   if(x % 2 != 0) //Pinta los efectos de los cuadros en blanco
	           {
	    		   //graphics2d.setPaint(new GradientPaint(80 * x+20, 80*y+50 , Color.lightGray, x * 80 -7, y * 80+7, Color.white, true));
	    		   graphics2d.setPaint(new GradientPaint(70 * x+270+25*x, 70*y+50+25*y , Color.RED, x * 70 -7 +25*x, y * 70+7 +25*y, Color.RED, true));
	           }
	           else //Pinta los efectosde los cuadros en negro
	           {
	               //graphics2d.setPaint(new GradientPaint(80 * x+20,80*y+50 , Color.black, x * 80-7 , y * 80+7 , Color.gray, true));
	        	   graphics2d.setPaint(new GradientPaint(70 * x+270+25*x,70*y+50 +25*y, Color.RED, x * 70-7 +25*x, y * 70+7 +25*y, Color.RED, true));
	           }
	        } 
	        else 
	        	if(x % 2 != 0)
		        {
		        	//graphics2d.setPaint(new GradientPaint(80 * x+20, 80*y+50 , Color.black, x * 80 -7, y * 80+7, Color.gray, true));
	        		graphics2d.setPaint(new GradientPaint(70 * x+270+25*x, 70*y+50+25*y , Color.RED, x * 70 -7+25*x, y * 70+7+25*y, Color.RED, true));
	     	       	        
		        }
		        else
		        {
		        	//graphics2d.setPaint(new GradientPaint(80 * x+20,80*y+50 , Color.lightGray, x * 80 -7, y * 80+7, Color.white, true));
		        	graphics2d.setPaint(new GradientPaint(70 * x+270+25*x,70*y+50+25*y , Color.RED, x * 70 -7+25*x, y * 70+7+25*y, Color.RED, true));
			        
		        }
	        
	        //dibujo cada cuadrado
	        //graphics2d.fillRect(80 * x+20,80*y+50 ,80,80);
	       graphics2d.fillRect(70 * x+270+25*x,70*y+50+25*y ,70,70);
	       graphics2d.setColor(Color.black);
	       graphics2d.setStroke(new BasicStroke(3.0F)); //grosor
		   graphics2d.drawRect(70 * x+270+25*x,70*y+50+25*y,70,70);
	       
	   }
	   if (tipotabl == 2 || tipotabl == 6)
	   {
		 //Con el clearRect es como si te repintara los limites de cada rectangulo
	       //graphics2d.clearRect(80 * x+20, 80* y+50 , 80, 80);
		   graphics2d.clearRect(54 * x+200 + 84+14*x, 54* y+50+14*y , 54, 54);
		   
	       if(y % 2 != 0)
	       {
	    	   if(x % 2 != 0) //Pinta los efectos de los cuadros en blanco
	           {
	    		   //graphics2d.setPaint(new GradientPaint(80 * x+20, 80*y+50 , Color.lightGray, x * 80 -7, y * 80+7, Color.white, true));
	    		   graphics2d.setPaint(new GradientPaint(54 * x+200 + 84+14*x, 54*y+50+14*y , Color.RED, x * 54 -7+14*x, y * 54+7 + 14*y, Color.RED, true));
	           }
	           else //Pinta los efectosde los cuadros en negro
	           {
	               //graphics2d.setPaint(new GradientPaint(80 * x+20,80*y+50 , Color.black, x * 80-7 , y * 80+7 , Color.gray, true));
	        	   graphics2d.setPaint(new GradientPaint(54 * x+200 + 84+14*x,54*y+50+14*y , Color.RED, x * 54-7+14*x , y * 54+7 + 14*y, Color.RED, true));
	           }
	        } 
	        else 
	        	if(x % 2 != 0)
		        {
		        	//graphics2d.setPaint(new GradientPaint(80 * x+20, 80*y+50 , Color.black, x * 80 -7, y * 80+7, Color.gray, true));
	        		graphics2d.setPaint(new GradientPaint(54 * x+200 + 84+14*x, 54*y+50+14*y , Color.RED, x * 54 -7+14*x, y * 54+7 +14*y, Color.RED, true));
	     	       	        
		        }
		        else
		        {
		        	//graphics2d.setPaint(new GradientPaint(80 * x+20,80*y+50 , Color.lightGray, x * 80 -7, y * 80+7, Color.white, true));
		        	graphics2d.setPaint(new GradientPaint(54 * x+200 + 84+14*x,54*y+50+14*y , Color.RED, x * 54 -7+14*x, y * 54+7+14*y, Color.RED, true));
			        
		        }
	        
	        //dibujo cada cuadrado
	        //graphics2d.fillRect(80 * x+20,80*y+50 ,80,80);
	       graphics2d.fillRect(54 * x+200 + 84+14*x,54*y+50+14*y ,54,54);
	       graphics2d.setColor(Color.black);
	       graphics2d.setStroke(new BasicStroke(2.0F)); //grosor
		   graphics2d.drawRect(54 * x+200 + 84+14*x,54*y+50+14*y ,54,54);
	   }
	   if (tipotabl == 3 || tipotabl == 5)
	   {
		 //Con el clearRect es como si te repintara los limites de cada rectangulo
	       //graphics2d.clearRect(80 * x+20, 80* y+50 , 80, 80);
		   graphics2d.clearRect(54 * x+200 + 84+14*x, 54* y+50 + 14*y , 54, 54);
		   
			   //graphics2d.clearRect(60 * x+200, 60* y+50 , 60, 60);

	       if(y % 2 != 0)
	       {
	    	   if(x % 2 != 0) //Pinta los efectos de los cuadros en blanco
	           {
	    		   //graphics2d.setPaint(new GradientPaint(80 * x+20, 80*y+50 , Color.lightGray, x * 80 -7, y * 80+7, Color.white, true));
	    		   graphics2d.setPaint(new GradientPaint(54 * x+200 + 84+14*x, 54*y+50+14*y , Color.RED, x * 54 -7+14*x, y * 54+7+14*y, Color.RED, true));
	           }
	           else //Pinta los efectosde los cuadros en negro
	           {
	               //graphics2d.setPaint(new GradientPaint(80 * x+20,80*y+50 , Color.black, x * 80-7 , y * 80+7 , Color.gray, true));
	        	   graphics2d.setPaint(new GradientPaint(54 * x+200 + 84+14*x,54*y+50+14*y , Color.RED, x * 54-7+14*x , y * 54+7+14*y , Color.RED, true));
	           }
	        } 
	        else 
	        	if(x % 2 != 0)
		        {
		        	//graphics2d.setPaint(new GradientPaint(80 * x+20, 80*y+50 , Color.black, x * 80 -7, y * 80+7, Color.gray, true));
	        		graphics2d.setPaint(new GradientPaint(54 * x+200 + 84+14*x, 54*y+50+14*y , Color.RED, x * 54 -7+14*x, y * 54+7+14*y, Color.RED, true));
	     	       	        
		        }
		        else
		        {
		        	//graphics2d.setPaint(new GradientPaint(80 * x+20,80*y+50 , Color.lightGray, x * 80 -7, y * 80+7, Color.white, true));
		        	graphics2d.setPaint(new GradientPaint(54 * x+200 + 84+14*x,54*y+50+14*y , Color.RED, x * 54 -7+14*x, y * 54+7+14*y, Color.RED, true));
			        
		        }
		   
	        //dibujo cada cuadrado
	        //graphics2d.fillRect(80 * x+20,80*y+50 ,80,80);
	       graphics2d.fillRect(54 * x+200 + 84+14*x,54*y+50+14*y ,54,54);
	       graphics2d.setColor(Color.black);
	       graphics2d.setStroke(new BasicStroke(2.0F)); //grosor
		   graphics2d.drawRect(54 * x+200 + 84+14*x,54*y+50+14*y ,54,54);
	   } 
	      
    }
   
   public void pintarPieza(int colorficha, int j, int i, boolean actualizaDibujo)
    {
	   //colorficha --> 1 (blanca), 2 (negra), 30 (ficha seleccion)
        Graphics2D graphics2d = (Graphics2D)buffer.getGraphics();
        Image imagenFicha;
       
        
        String name="";
        Color c = new Color(102,255,102);
        if (tipotabl == 1)
        {
        	graphics2d.setColor(Color.red);
            graphics2d.fillRect(340,85,25,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(435,85,25,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(530,85,25,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(625,85,25,6);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(340,180,25,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(435,180,25,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(530,180,25,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(625,180,25,6);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(340,275,25,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(435,275,25,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(530,275,25,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(625,275,25,6);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(340,370,25,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(435,370,25,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(530,370,25,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(625,370,25,6);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(340,460,25,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(435,460,25,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(530,460,25,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(625,460,25,6);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(305,120,6,25);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(305,215,6,25);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(305,310,6,25);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(305,405,6,25);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(400,120,6,25);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(400,215,6,25);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(400,310,6,25);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(400,405,6,25);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(485,120,6,25);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(485,215,6,25);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(485,310,6,25);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(485,405,6,25);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(590,120,6,25);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(590,215,6,25);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(590,310,6,25);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(590,405,6,25);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(675,120,6,25);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(675,215,6,25);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(675,310,6,25);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(675,405,6,25);
            
            //cruzadas Linea 1
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(340, 120, 365, 145);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(365, 120, 340, 145);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(435, 120, 460, 145);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(460, 120, 435, 145);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(530, 120, 555, 145);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(555, 120, 530, 145);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(625, 120, 650, 145);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(650, 120, 625, 145);
            
            //Cruzadas Linea 2
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(340, 215, 365, 240);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(365, 215, 340, 240);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(435, 215, 460, 240);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(460, 215, 435, 240);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(530, 215, 555, 240);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(555, 215, 530, 240);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(625, 215, 650, 240);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(650, 215, 625, 240);
            
            //linea 3 cruzadas
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(340, 310, 365, 335);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(365, 310, 340, 335);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(435, 310, 460, 335);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(460, 310, 435, 335);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(530, 310, 555, 335);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(555, 310, 530, 335);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(625, 310, 650, 335);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(650, 310, 625, 335);
            
          //linea 4 cruzadas
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(340, 405, 365, 430);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(365, 405, 340, 430);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(435, 405, 460, 430);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(460, 405, 435, 430);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(530, 405, 555, 430);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(555, 405, 530, 430);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(625, 405, 650, 430);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(650, 405, 625, 430);
            
            /*
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(280, 130, 660, 510);
		   	  */
	        if(colorficha == 1 && (i%2 == j%2))
	        {
	        	name="fichaBlancan.jpg";
	        	//name="fichaBlancab.jpg"; //ficha blanca sobre fondo blanco
	        }
	        else if(colorficha == 1 && (i%2 != j%2))
	        {
	        	name="fichaBlancan.jpg"; //ficha blanca sobre fondo negro
	        	
	        }
	        else if(colorficha == 2 && (i%2 == j%2))
	        {
	        	name="fichaNegrab.jpg"; //ficha negra sobre fondo blanco        	
	        }
	        else if(colorficha == 2 && (i%2 != j%2))
	        {
	        	name="fichaNegrab.jpg";
	        	//name="fichaNegran.jpg"; //ficha negra sobre fondo negro
	        }
	       
	        else if(colorficha==30 && i%2 == j%2) //le damos el valor de 30 por darle un valor distinto al numero de jugador
	        {
	        	name="seleccionBlanco.jpg"; //seleccion sobre fondo blanco
	        }
	        else if (colorficha == 30 && i%2 != j%2)
	        {
	        	name = "seleccionNegro.jpg"; //seleccion sobre fondo blanco
	        }
	
	        //Una vez cargada la ficha, la dibujamos en el tablero en su posicion (drawImage pone primero j y luego i)
	        
	        imagenFicha = new ImageIcon(getClass().getResource(ruta + name)).getImage();
	        //graphics2d.drawImage(imagenFicha, 80 * i+20, 80*j+50, this);
	        graphics2d.drawImage(imagenFicha, 70 * i+270+25*i, 70*j+50+25*j, this);
	       // graphics2d.fillRect(60 * i+200,60*j+50 ,60,60);
	        
        }
        if (tipotabl == 2)
        {
        	graphics2d.setColor(Color.red);
            graphics2d.fillRect(254 + 84,80,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(322 + 84,80,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(390 + 84,80,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(458 + 84,80,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(526 + 84,80,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(594 + 84,80,14,6);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(254 + 84,148,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(322 + 84,148,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(390 + 84,148,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(458 + 84,148,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(526 + 84,148,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(594 + 84,148,14,6);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(254 + 84,216,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(322 + 84,216,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(390 + 84,216,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(458 + 84,216,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(526 + 84,216,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(594 + 84,216,14,6);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(254 + 84,284,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(322 + 84,284,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(390 + 84,284,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(458 + 84,284,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(526 + 84,284,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(594 + 84,284,14,6);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(254 + 84,352,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(322 + 84,352,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(390 + 84,352,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(458 + 84,352,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(526 + 84,352,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(594 + 84,352,14,6);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(254 + 84,420,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(322 + 84,420,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(390 + 84,420,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(458 + 84,420,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(526 + 84,420,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(594 + 84,420,14,6);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(254 + 84,488,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(322 + 84,488,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(390 + 84,488,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(458 + 84,488,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(526 + 84,488,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(594 + 84,488,14,6);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(227 + 84,104,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(227 + 84,172,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(227 + 84,240,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(227 + 84,308,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(227 + 84,376,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(227 + 84,444,6,14);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(295 + 84,104,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(295 + 84,172,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(295 + 84,240,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(295 + 84,308,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(295 + 84,376,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(295 + 84,444,6,14);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(363 + 84,104,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(363 + 84,172,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(363 + 84,240,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(363 + 84,308,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(363 + 84,376,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(363 + 84,444,6,14);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(431 + 84,104,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(431 + 84,172,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(431 + 84,240,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(431 + 84,308,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(431 + 84,376,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(431 + 84,444,6,14);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(499 + 84,104,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(499 + 84,172,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(499 + 84,240,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(499 + 84,308,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(499 + 84,376,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(499 + 84,444,6,14);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(567 + 84,104,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(567 + 84,172,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(567 + 84,240,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(567 + 84,308,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(567 + 84,376,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(567 + 84,444,6,14);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(635 + 84,104,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(635 + 84,172,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(635 + 84,240,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(635 + 84,308,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(635 + 84,376,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(635 + 84,444,6,14);
            
          //cruzadas(cruz original)///////////////////////////////////////////////////
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(390 + 84, 104, 404 + 84, 118);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 118, 472 + 84, 104);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(404 + 84, 172, 390 + 84, 186);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 172, 472 + 84, 186);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(390 + 84, 240, 404 + 84, 254);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 254, 472 + 84, 240);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(404 + 84, 308, 390 + 84, 322);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 308, 472 + 84, 322);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(390 + 84, 376, 404 + 84, 390);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 390, 472 + 84, 376);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(404 + 84, 444, 390 + 84, 458);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 444, 472 + 84, 458);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(336 + 84, 240, 322 + 84, 254);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(322 + 84, 308, 336 + 84, 322);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(254 + 84, 240, 268 + 84, 254);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(254 + 84, 322, 268 + 84, 308);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(526 + 84, 240, 540 + 84, 254);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(540 + 84, 308, 526 + 84, 322);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(608 + 84, 240, 594 + 84, 254);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(608 + 84, 322, 594 + 84, 308);
            //Hasta aquí cruz original//////////////////////////////////////////////
            
            /// Cruzadas (cruz sin restri) y 7x7 sin restri/////////////////////////
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(390 + 84, 118, 404 + 84, 104);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 104, 472 + 84, 118);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(404 + 84, 186, 390 + 84, 172);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 186, 472 + 84, 172);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(390 + 84, 254, 404 + 84, 240);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 240, 472 + 84, 254);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(404 + 84, 322, 390 + 84, 308);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 322, 472 + 84, 308);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(390 + 84, 390, 404 + 84, 376);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 376, 472 + 84, 390);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(404 + 84, 458, 390 + 84, 444);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 458, 472 + 84, 444);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(336 + 84, 254, 322 + 84, 240);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(322 + 84, 322, 336 + 84, 308);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(254 + 84, 254, 268 + 84, 240);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(254 + 84, 308, 268 + 84, 322);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(526 + 84, 254, 540 + 84, 240);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(540 + 84, 322, 526 + 84, 308);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(608 + 84, 254, 594 + 84, 240);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(608 + 84, 308, 594 + 84, 322);
            
            // Fin cruzadas (cruz Sin restri) y 7x7 sin restri ////////////////////////
            
            
            //7x7 restri (esquinas)/////////////////////////////////////////////////
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(254 + 84, 104, 268 + 84, 118);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(322 + 84, 118, 336 + 84, 104);
                        
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(526 + 84, 104, 540 + 84, 118);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(594 + 84, 118, 608 + 84, 104);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(268 + 84, 172, 254 + 84, 186);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(336 + 84, 186, 322 + 84, 172);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(540 + 84, 172, 526 + 84, 186);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(608 + 84, 186, 594 + 84, 172);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(254 + 84, 376, 268 + 84, 390);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(322 + 84, 390, 336 + 84, 376);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(526 + 84, 376, 540 + 84, 390);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(594 + 84, 390, 608 + 84, 376);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(254 + 84, 458, 268 + 84, 444);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(322 + 84, 444, 336 + 84, 458);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(526 + 84, 458, 540 + 84, 444);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(594 + 84, 444, 608 + 84, 458);
            //hasta aqui 7x7 restri(esquinas)//////////////////////////////////////
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(254 + 84, 118, 268 + 84, 104);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(322 + 84, 104, 336 + 84, 118);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(526 + 84, 118, 540 + 84, 104);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(594 + 84, 104, 608 + 84, 118);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(268 + 84, 186, 254 + 84, 172);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(336 + 84, 172, 322 + 84, 186);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(540 + 84, 186, 526 + 84, 172);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(608 + 84, 172, 594 + 84, 186);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(254 + 84, 390, 268 + 84, 376);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(322 + 84, 376, 336 + 84, 390);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(526 + 84, 390, 540 + 84, 376);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(594 + 84, 376, 608 + 84, 390);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(254 + 84, 444, 268 + 84, 458);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(322 + 84, 458, 336 + 84, 444);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(526 + 84, 444, 540 + 84, 458);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(594 + 84, 458, 608 + 84, 444);
            
            
            
	        if(colorficha == 1 && (i%2 == j%2))
	        {
	        	name="7_fichaBlancan.jpg";
	        	//name="7_fichaBlancab.jpg"; //ficha blanca sobre fondo blanco
	        }
	        else if(colorficha == 1 && (i%2 != j%2))
	        {
	        	name="7_fichaBlancan.jpg"; //ficha blanca sobre fondo negro
	        }
	        else if(colorficha == 2 && (i%2 == j%2))
	        {
	        	name="7_fichaBlancab.jpg";
	        	//name="7_fichaNegrab.jpg"; //ficha negra sobre fondo blanco        	
	        }
	        else if(colorficha == 2 && (i%2 != j%2))
	        {
	        	name="7_fichaBlancab.jpg";
	        	//name="7_fichaNegran.jpg"; //ficha negra sobre fondo negro
	        }
	       
	        else if(colorficha==30 && i%2 == j%2) //le damos el valor de 30 por darle un valor distinto al numero de jugador
	        {
	        	name="7_seleccionBlanco.jpg"; //seleccion sobre fondo blanco
	        }
	        else if (colorficha == 30 && i%2 != j%2)
	        {
	        	name = "7_seleccionNegro.jpg"; //seleccion sobre fondo blanco
	        }
	
	        //Una vez cargada la ficha, la dibujamos en el tablero en su posicion (drawImage pone primero j y luego i)
	        
	        imagenFicha = new ImageIcon(getClass().getResource(ruta + name)).getImage();
	        //graphics2d.drawImage(imagenFicha, 80 * i+20, 80*j+50, this);
	        graphics2d.drawImage(imagenFicha, 54 * i+200 + 84+14*i, 54*j+50+14*j, this);
        }
        if (tipotabl == 3)
        {
        	graphics2d.setColor(Color.RED);
            graphics2d.fillRect(390 + 84,80,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(458 + 84,80,14,6);
            
            
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(390 + 84,148,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(458 + 84,148,14,6);
            
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(254 + 84,216,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(322 + 84,216,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(390 + 84,216,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(458 + 84,216,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(526 + 84,216,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(594 + 84,216,14,6);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(254 + 84,284,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(322 + 84,284,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(390 + 84,284,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(458 + 84,284,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(526 + 84,284,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(594 + 84,284,14,6);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(254 + 84,352,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(322 + 84,352,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(390 + 84,352,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(458 + 84,352,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(526 + 84,352,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(594 + 84,352,14,6);
            
            
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(390 + 84,420,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(458 + 84,420,14,6);
            
            
            
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(390 + 84,488,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(458 + 84,488,14,6);
            
            
            
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(227 + 84,240,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(227 + 84,308,6,14);
            
            
            
            
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(295 + 84,240,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(295 + 84,308,6,14);
            
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(363 + 84,104,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(363 + 84,172,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(363 + 84,240,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(363 + 84,308,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(363 + 84,376,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(363 + 84,444,6,14);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(431 + 84,104,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(431 + 84,172,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(431 + 84,240,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(431 + 84,308,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(431 + 84,376,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(431 + 84,444,6,14);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(499 + 84,104,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(499 + 84,172,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(499 + 84,240,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(499 + 84,308,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(499 + 84,376,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(499 + 84,444,6,14);
            
            
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(567 + 84,240,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(567 + 84,308,6,14);
            
            
            
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(635 + 84,240,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(635 + 84,308,6,14);
            
            //cruzadas 
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(390 + 84, 104, 404 + 84, 118);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 118, 472 + 84, 104);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(404 + 84, 172, 390 + 84, 186);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 172, 472 + 84, 186);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(390 + 84, 240, 404 + 84, 254);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 254, 472 + 84, 240);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(404 + 84, 308, 390 + 84, 322);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 308, 472 + 84, 322);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(390 + 84, 376, 404 + 84, 390);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 390, 472 + 84, 376);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(404 + 84, 444, 390 + 84, 458);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 444, 472 + 84, 458);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(336 + 84, 240, 322 + 84, 254);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(322 + 84, 308, 336 + 84, 322);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(254 + 84, 240, 268 + 84, 254);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(254 + 84, 322, 268 + 84, 308);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(526 + 84, 240, 540 + 84, 254);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(540 + 84, 308, 526 + 84, 322);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(608 + 84, 240, 594 + 84, 254);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(608 + 84, 322, 594 + 84, 308);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(390 + 84, 118, 404 + 84, 104);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 104, 472 + 84, 118);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(404 + 84, 186, 390 + 84, 172);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 186, 472 + 84, 172);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(390 + 84, 254, 404 + 84, 240);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 240, 472 + 84, 254);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(404 + 84, 322, 390 + 84, 308);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 322, 472 + 84, 308);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(390 + 84, 390, 404 + 84, 376);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 376, 472 + 84, 390);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(404 + 84, 458, 390 + 84, 444);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 458, 472 + 84, 444);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(336 + 84, 254, 322 + 84, 240);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(322 + 84, 322, 336 + 84, 308);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(254 + 84, 254, 268 + 84, 240);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(254 + 84, 308, 268 + 84, 322);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(526 + 84, 254, 540 + 84, 240);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(540 + 84, 322, 526 + 84, 308);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(608 + 84, 254, 594 + 84, 240);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(608 + 84, 308, 594 + 84, 322);
            
        	if(colorficha == 1 && (i%2 == j%2))
	        {
	        	name="7_fichaBlancan.jpg";
	        	//name="7_fichaBlancab.jpg"; //ficha blanca sobre fondo blanco
	        }
	        else if(colorficha == 1 && (i%2 != j%2))
	        {
	        	name="7_fichaBlancan.jpg"; //ficha blanca sobre fondo negro
	        }
	        else if(colorficha == 2 && (i%2 == j%2))
	        {
	        	name="7_fichaBlancab.jpg";
	        	//name="7_fichaNegrab.jpg"; //ficha negra sobre fondo blanco        	
	        }
	        else if(colorficha == 2 && (i%2 != j%2))
	        {
	        	name="7_fichaBlancab.jpg";
	        	//name="7_fichaNegran.jpg"; //ficha negra sobre fondo negro
	        }
	       
	        else if(colorficha==30 && i%2 == j%2) //le damos el valor de 30 por darle un valor distinto al numero de jugador
	        {
	        	name="7_seleccionBlanco.jpg"; //seleccion sobre fondo blanco
	        }
	        else if (colorficha == 30 && i%2 != j%2)
	        {
	        	name = "7_seleccionNegro.jpg"; //seleccion sobre fondo blanco
	        }
	
	        //Una vez cargada la ficha, la dibujamos en el tablero en su posicion (drawImage pone primero j y luego i)
	        
	        imagenFicha = new ImageIcon(getClass().getResource(ruta + name)).getImage();
	        //graphics2d.drawImage(imagenFicha, 80 * i+20, 80*j+50, this);
	        graphics2d.drawImage(imagenFicha, 54 * i+200 + 84+14*i, 54*j+50+14*j, this);
        }
        if (tipotabl == 4)
        {
        	graphics2d.setColor(Color.red);
            graphics2d.fillRect(340,85,25,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(435,85,25,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(530,85,25,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(625,85,25,6);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(340,180,25,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(435,180,25,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(530,180,25,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(625,180,25,6);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(340,275,25,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(435,275,25,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(530,275,25,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(625,275,25,6);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(340,370,25,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(435,370,25,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(530,370,25,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(625,370,25,6);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(340,460,25,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(435,460,25,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(530,460,25,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(625,460,25,6);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(305,120,6,25);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(305,215,6,25);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(305,310,6,25);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(305,405,6,25);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(400,120,6,25);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(400,215,6,25);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(400,310,6,25);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(400,405,6,25);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(485,120,6,25);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(485,215,6,25);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(485,310,6,25);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(485,405,6,25);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(590,120,6,25);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(590,215,6,25);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(590,310,6,25);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(590,405,6,25);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(675,120,6,25);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(675,215,6,25);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(675,310,6,25);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(675,405,6,25);
            
            //cruzadas Linea 1
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(340, 120, 365, 145);
            /*
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(365, 120, 340, 145);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(435, 120, 460, 145);
            */
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(460, 120, 435, 145);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(530, 120, 555, 145);
            /*
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(555, 120, 530, 145);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(625, 120, 650, 145);
            */
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(650, 120, 625, 145);
            
            //Cruzadas Linea 2
            /*
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(340, 215, 365, 240);
            */
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(365, 215, 340, 240);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(435, 215, 460, 240);
            /*
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(460, 215, 435, 240);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(530, 215, 555, 240);
            */
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(555, 215, 530, 240);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(625, 215, 650, 240);
            /*
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(650, 215, 625, 240);
            */
            //linea 3 cruzadas
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(340, 310, 365, 335);
            /*
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(365, 310, 340, 335);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(435, 310, 460, 335);
            */
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(460, 310, 435, 335);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(530, 310, 555, 335);
            /*
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(555, 310, 530, 335);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(625, 310, 650, 335);
            */
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(650, 310, 625, 335);
            
          //linea 4 cruzadas
            /*
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(340, 405, 365, 430);
            */
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(365, 405, 340, 430);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(435, 405, 460, 430);
            /*
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(460, 405, 435, 430);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(530, 405, 555, 430);
            */
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(555, 405, 530, 430);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(625, 405, 650, 430);
            /*
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(650, 405, 625, 430);
            */
            /*
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(280, 130, 660, 510);
		   	  */
	        if(colorficha == 1 && (i%2 == j%2))
	        {
	        	name="fichaBlancan.jpg";
	        	//name="fichaBlancab.jpg"; //ficha blanca sobre fondo blanco
	        }
	        else if(colorficha == 1 && (i%2 != j%2))
	        {
	        	name="fichaBlancan.jpg"; //ficha blanca sobre fondo negro
	        	
	        }
	        else if(colorficha == 2 && (i%2 == j%2))
	        {
	        	name="fichaNegrab.jpg"; //ficha negra sobre fondo blanco        	
	        }
	        else if(colorficha == 2 && (i%2 != j%2))
	        {
	        	name="fichaNegrab.jpg";
	        	//name="fichaNegran.jpg"; //ficha negra sobre fondo negro
	        }
	       
	        else if(colorficha==30 && i%2 == j%2) //le damos el valor de 30 por darle un valor distinto al numero de jugador
	        {
	        	name="seleccionBlanco.jpg"; //seleccion sobre fondo blanco
	        }
	        else if (colorficha == 30 && i%2 != j%2)
	        {
	        	name = "seleccionNegro.jpg"; //seleccion sobre fondo blanco
	        }
	
	        //Una vez cargada la ficha, la dibujamos en el tablero en su posicion (drawImage pone primero j y luego i)
	        
	        imagenFicha = new ImageIcon(getClass().getResource(ruta + name)).getImage();
	        //graphics2d.drawImage(imagenFicha, 80 * i+20, 80*j+50, this);
	        graphics2d.drawImage(imagenFicha, 70 * i+270+25*i, 70*j+50+25*j, this);
	       // graphics2d.fillRect(60 * i+200,60*j+50 ,60,60);
        }
        if (tipotabl == 6)
        {
        	graphics2d.setColor(Color.red);
            graphics2d.fillRect(254 + 84,80,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(322 + 84,80,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(390 + 84,80,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(458 + 84,80,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(526 + 84,80,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(594 + 84,80,14,6);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(254 + 84,148,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(322 + 84,148,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(390 + 84,148,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(458 + 84,148,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(526 + 84,148,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(594 + 84,148,14,6);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(254 + 84,216,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(322 + 84,216,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(390 + 84,216,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(458 + 84,216,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(526 + 84,216,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(594 + 84,216,14,6);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(254 + 84,284,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(322 + 84,284,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(390 + 84,284,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(458 + 84,284,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(526 + 84,284,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(594 + 84,284,14,6);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(254 + 84,352,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(322 + 84,352,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(390 + 84,352,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(458 + 84,352,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(526 + 84,352,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(594 + 84,352,14,6);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(254 + 84,420,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(322 + 84,420,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(390 + 84,420,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(458 + 84,420,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(526 + 84,420,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(594 + 84,420,14,6);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(254 + 84,488,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(322 + 84,488,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(390 + 84,488,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(458 + 84,488,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(526 + 84,488,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(594 + 84,488,14,6);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(227 + 84,104,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(227 + 84,172,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(227 + 84,240,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(227 + 84,308,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(227 + 84,376,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(227 + 84,444,6,14);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(295 + 84,104,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(295 + 84,172,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(295 + 84,240,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(295 + 84,308,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(295 + 84,376,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(295 + 84,444,6,14);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(363 + 84,104,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(363 + 84,172,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(363 + 84,240,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(363 + 84,308,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(363 + 84,376,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(363 + 84,444,6,14);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(431 + 84,104,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(431 + 84,172,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(431 + 84,240,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(431 + 84,308,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(431 + 84,376,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(431 + 84,444,6,14);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(499 + 84,104,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(499 + 84,172,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(499 + 84,240,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(499 + 84,308,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(499 + 84,376,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(499 + 84,444,6,14);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(567 + 84,104,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(567 + 84,172,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(567 + 84,240,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(567 + 84,308,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(567 + 84,376,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(567 + 84,444,6,14);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(635 + 84,104,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(635 + 84,172,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(635 + 84,240,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(635 + 84,308,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(635 + 84,376,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(635 + 84,444,6,14);
            
          //cruzadas(cruz original)///////////////////////////////////////////////////
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(390 + 84, 104, 404 + 84, 118);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 118, 472 + 84, 104);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(404 + 84, 172, 390 + 84, 186);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 172, 472 + 84, 186);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(390 + 84, 240, 404 + 84, 254);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 254, 472 + 84, 240);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(404 + 84, 308, 390 + 84, 322);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 308, 472 + 84, 322);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(390 + 84, 376, 404 + 84, 390);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 390, 472 + 84, 376);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(404 + 84, 444, 390 + 84, 458);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 444, 472 + 84, 458);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(336 + 84, 240, 322 + 84, 254);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(322 + 84, 308, 336 + 84, 322);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(254 + 84, 240, 268 + 84, 254);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(254 + 84, 322, 268 + 84, 308);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(526 + 84, 240, 540 + 84, 254);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(540 + 84, 308, 526 + 84, 322);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(608 + 84, 240, 594 + 84, 254);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(608 + 84, 322, 594 + 84, 308);
            //Hasta aquí cruz original//////////////////////////////////////////////
            
            
            //7x7 restri (esquinas)/////////////////////////////////////////////////
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(254 + 84, 104, 268 + 84, 118);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(322 + 84, 118, 336 + 84, 104);
                        
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(526 + 84, 104, 540 + 84, 118);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(594 + 84, 118, 608 + 84, 104);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(268 + 84, 172, 254 + 84, 186);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(336 + 84, 186, 322 + 84, 172);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(540 + 84, 172, 526 + 84, 186);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(608 + 84, 186, 594 + 84, 172);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(254 + 84, 376, 268 + 84, 390);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(322 + 84, 390, 336 + 84, 376);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(526 + 84, 376, 540 + 84, 390);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(594 + 84, 390, 608 + 84, 376);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(254 + 84, 458, 268 + 84, 444);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(322 + 84, 444, 336 + 84, 458);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(526 + 84, 458, 540 + 84, 444);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(594 + 84, 444, 608 + 84, 458);
            //hasta aqui 7x7 restri(esquinas)//////////////////////////////////////
            
            
        	if(colorficha == 1 && (i%2 == j%2))
	        {
	        	name="7_fichaBlancan.jpg";
	        	//name="7_fichaBlancab.jpg"; //ficha blanca sobre fondo blanco
	        }
	        else if(colorficha == 1 && (i%2 != j%2))
	        {
	        	name="7_fichaBlancan.jpg"; //ficha blanca sobre fondo negro
	        }
	        else if(colorficha == 2 && (i%2 == j%2))
	        {
	        	name="7_fichaBlancab.jpg";
	        	//name="7_fichaNegrab.jpg"; //ficha negra sobre fondo blanco        	
	        }
	        else if(colorficha == 2 && (i%2 != j%2))
	        {
	        	name="7_fichaBlancab.jpg";
	        	//name="7_fichaNegran.jpg"; //ficha negra sobre fondo negro
	        }
	       
	        else if(colorficha==30 && i%2 == j%2) //le damos el valor de 30 por darle un valor distinto al numero de jugador
	        {
	        	name="7_seleccionBlanco.jpg"; //seleccion sobre fondo blanco
	        }
	        else if (colorficha == 30 && i%2 != j%2)
	        {
	        	name = "7_seleccionNegro.jpg"; //seleccion sobre fondo blanco
	        }
	
	        //Una vez cargada la ficha, la dibujamos en el tablero en su posicion (drawImage pone primero j y luego i)
	        
	        imagenFicha = new ImageIcon(getClass().getResource(ruta + name)).getImage();
	        //graphics2d.drawImage(imagenFicha, 80 * i+20, 80*j+50, this);
	        graphics2d.drawImage(imagenFicha, 54 * i+200 + 84+14*i, 54*j+50+14*j, this);
        }
        if (tipotabl == 5)
        {
        	
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(390 + 84,80,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(458 + 84,80,14,6);
            
            
            
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(390 + 84,148,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(458 + 84,148,14,6);
            
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(254 + 84,216,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(322 + 84,216,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(390 + 84,216,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(458 + 84,216,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(526 + 84,216,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(594 + 84,216,14,6);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(254 + 84,284,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(322 + 84,284,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(390 + 84,284,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(458 + 84,284,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(526 + 84,284,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(594 + 84,284,14,6);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(254 + 84,352,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(322 + 84,352,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(390 + 84,352,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(458 + 84,352,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(526 + 84,352,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(594 + 84,352,14,6);
            
            
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(390 + 84,420,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(458 + 84,420,14,6);
            
            
            
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(390 + 84,488,14,6);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(458 + 84,488,14,6);
            
            
            
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(227 + 84,240,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(227 + 84,308,6,14);
            
            
            
            
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(295 + 84,240,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(295 + 84,308,6,14);
            
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(363 + 84,104,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(363 + 84,172,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(363 + 84,240,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(363 + 84,308,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(363 + 84,376,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(363 + 84,444,6,14);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(431 + 84,104,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(431 + 84,172,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(431 + 84,240,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(431 + 84,308,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(431 + 84,376,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(431 + 84,444,6,14);
            
            graphics2d.setColor(Color.red);
            graphics2d.fillRect(499 + 84,104,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(499 + 84,172,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(499 + 84,240,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(499 + 84,308,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(499 + 84,376,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(499 + 84,444,6,14);
            
            
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(567 + 84,240,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(567 + 84,308,6,14);
            
            
            
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(635 + 84,240,6,14);
            graphics2d.setColor(Color.RED);
            graphics2d.fillRect(635 + 84,308,6,14);
            
            //cruzadas
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(390 + 84, 104, 404 + 84, 118);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 118, 472 + 84, 104);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(404 + 84, 172, 390 + 84, 186);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 172, 472 + 84, 186);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(390 + 84, 240, 404 + 84, 254);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 254, 472 + 84, 240);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(404 + 84, 308, 390 + 84, 322);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 308, 472 + 84, 322);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(390 + 84, 376, 404 + 84, 390);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 390, 472 + 84, 376);
            
          
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(404 + 84, 444, 390 + 84, 458);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(458 + 84, 444, 472 + 84, 458);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(336 + 84, 240, 322 + 84, 254);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(322 + 84, 308, 336 + 84, 322);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(254 + 84, 240, 268 + 84, 254);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(254 + 84, 322, 268 + 84, 308);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(526 + 84, 240, 540 + 84, 254);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(540 + 84, 308, 526 + 84, 322);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(608 + 84, 240, 594 + 84, 254);
            
            graphics2d.setColor(Color.RED);
            graphics2d.setStroke(new BasicStroke(5.0F)); //grosor
            graphics2d.drawLine(608 + 84, 322, 594 + 84, 308);
            
        	if(colorficha == 1 && (i%2 == j%2))
	        {
	        	name="7_fichaBlancan.jpg";
	        	//name="7_fichaBlancab.jpg"; //ficha blanca sobre fondo blanco
	        }
	        else if(colorficha == 1 && (i%2 != j%2))
	        {
	        	name="7_fichaBlancan.jpg"; //ficha blanca sobre fondo negro
	        }
	        else if(colorficha == 2 && (i%2 == j%2))
	        {
	        	name="7_fichaBlancab.jpg";
	        	//name="7_fichaNegrab.jpg"; //ficha negra sobre fondo blanco        	
	        }
	        else if(colorficha == 2 && (i%2 != j%2))
	        {
	        	name="7_fichaBlancab.jpg";
	        	//name="7_fichaNegran.jpg"; //ficha negra sobre fondo negro
	        }
	       
	        else if(colorficha==30 && i%2 == j%2) //le damos el valor de 30 por darle un valor distinto al numero de jugador
	        {
	        	name="7_seleccionBlanco.jpg"; //seleccion sobre fondo blanco
	        }
	        else if (colorficha == 30 && i%2 != j%2)
	        {
	        	name = "7_seleccionNegro.jpg"; //seleccion sobre fondo blanco
	        }
	
	        //Una vez cargada la ficha, la dibujamos en el tablero en su posicion (drawImage pone primero j y luego i)
	        
	        imagenFicha = new ImageIcon(getClass().getResource(ruta + name)).getImage();
	        //graphics2d.drawImage(imagenFicha, 80 * i+20, 80*j+50, this);
	        graphics2d.drawImage(imagenFicha, 54 * i+200 + 84+14*i, 54*j+50+14*j, this);
        }
 
        if(actualizaDibujo)
        {
        	Graphics g = getGraphics();
            g.drawImage(buffer, 0, 0, this);
        }
  
    }
   
//Refresca el dibujo del tablero
   public void update(Graphics g)
   {	
	   
	   paint(getGraphics()); //Se usa este para cuando se cambie el color del fondo
       g.drawImage(buffer, 0, 0, this); //Se usa para actualizar los cambios del tablero
   }
   
   public void itemStateChanged( ItemEvent e )
   {   	
//**************para cambiar de color al fondo con estos item 
   	if(e.getSource()==mColor1)
   	{
   		mColor2.setState(false);
   		mColor3.setState(false);
   		mColor4.setState(false);
   		mColor5.setState(false);
   		mColor6.setState(false);
        colorFondo1 = Color.red;
        repaint();
        return;
     }
   	
     if(e.getSource()==mColor2)
     {
        mColor1.setState(false);
        mColor3.setState(false);
        mColor4.setState(false);
        mColor5.setState(false);
   		mColor6.setState(false);
        colorFondo1 = Color.blue;
        repaint();
        return;
     }
     
     if(e.getSource()==mColor3)
     {
     	mColor1.setState(false);
     	mColor2.setState(false);
     	mColor4.setState(false);
     	mColor5.setState(false);
   		mColor6.setState(false);
        colorFondo1 = Color.yellow;
        repaint();
        return;
      }
     
     if(e.getSource()==mColor4)
     {
        mColor2.setState(false);
        mColor3.setState(false);
        mColor1.setState(false);
        mColor5.setState(false);
        mColor6.setState(false);
        colorFondo1 = Color.green;
        repaint();
        return;
      }
     
     if(e.getSource()==mColor5)
     {
        mColor2.setState(false);
        mColor3.setState(false);
        mColor4.setState(false);
        mColor1.setState(false);
        mColor6.setState(false);
        colorFondo1 = Color.DARK_GRAY;
        repaint();
        return;
     }
     
     if(e.getSource()==mColor6)
     {
   	    Color PaleGreen = new Color(152,251,152); //98fb98
        mColor2.setState(false);
        mColor3.setState(false);
        mColor4.setState(false);
        mColor1.setState(false);
        mColor5.setState(false);
        colorFondo1 = PaleGreen;
        repaint();
        return;
     }	
     
     if(e.getSource()==mTotalMov1)
     {
    	mTotalMov1.setState(true);
    	mTotalMov2.setState(false);
    	mTotalMov3.setState(false);
    	mTotalMov4.setState(false);
        totalMovimientos = 10;
        return;
      }
     
      if(e.getSource()==mTotalMov2)
      {
       	mTotalMov2.setState(true);mTotalMov1.setState(false);mTotalMov3.setState(false);mTotalMov4.setState(false);
        totalMovimientos = 10;return;
      }
      
      if(e.getSource()==mTotalMov3)
      {
       	mTotalMov3.setState(true);mTotalMov2.setState(false);mTotalMov1.setState(false);mTotalMov4.setState(false);
        totalMovimientos = 10;return;
      } 
     
      if(e.getSource()==mTotalMov4)
      {
       	mTotalMov4.setState(true);mTotalMov2.setState(false);mTotalMov3.setState(false);mTotalMov1.setState(false);
        totalMovimientos = 10;return;
      }      
   }
   
   public void actionPerformed(ActionEvent actionevent)
   {
	   if(actionevent.getSource() == mNueva)
	   {
		   reinicia();
		   return;
       }	
	   
	   if(actionevent.getSource() == mTotalMov)
       {
        		
       }
        	
       if(actionevent.getSource() == mEstadisticas)
       {
    	   //if(numjugadores == 2)
    	   //{
    		   Opciones tem= new Opciones(this);
    		   tem.mostrar("Estadisticas jug2");
    	   //}	
        }	
       
	   	if(mComo== actionevent.getSource())
	   	{
	   		Opciones tem= new Opciones(this);tem.mostrar("Como jugar");return;
	   	}
	   	
	   	if(mAcerca== actionevent.getSource())
	   	{
	   		Opciones tem= new Opciones(this);tem.mostrar("Acerca de Zorra y Gansos");return;
	   	}
	   	
	   	if(mSalir==actionevent.getSource())
	   		cerrar("Desea Salir");
   }

   public void mouseClicked(MouseEvent mouseevent)
   {
	   label0:
	   {
	
	   		int posSeleccionada = -1;; //posicion de la seleccionada
			int posCandidata = -1; //posicion de la candidata 
	    	int numCasillaCandidata= -1;
		 	int numCasillaSeleccionada = -1;
		 	int numCasillaSaltoActivo = -1;
		 	int casilla_borrar = -1;
			
		 	if (tipotabl == 1)
			{
			 	if(tablero.jugadores[turno-1].esPC && cuentaEmpezar==0)
			 	{
			 		cuentaEmpezar = 1;
		        	tiempo.start();
			 	}	 	
	    	
	    	//caso en el que hacemos un solo click
			 	if(mouseevent.getClickCount() == 1)
		    	{    		
		    		Graphics2D graphics2d = (Graphics2D)getGraphics();
		            int l = mouseevent.getX();
		            int k = mouseevent.getY();
		            
		            //if(l <= 20 || l >= 660 || k <=50 || k >= 690)
		            //if(l <= 200 || l >= 800 || k <=50 || k >= 690)
		            if(l <= 270 || l >= 720 || k <=50 || k >= 500)
		            	break label0;
	            
		            detenerJuego = false;
		            
		            if(compruebaGanador()!= 0)
		            {
		            	detenerJuego = true;
		            }
		            
		            if(tablero.jugadores[turno-1].esPC)
		            {
		            	mover_pc();
		            	
		            	if(detenerJuego)//Implica que se ha terminado la partida
		            	{
		            		muestraGanador();
		            	}
	                       	
		            }
		            
	///// MIRAR TODO ESTO LOS BUCLES Y TAL Y TAL ////////////////////////////////////
		            // No es PC, es jugador normal.
		            else
		            {
			            //Calcula la coordenada i,j del tablero 
			            //int i = Math.round((l-20) / 80);
		            	//int i = Math.round((l-200) / 80);
			           // int j = Math.round((k-50) / 80);
			            int i = 8, j = 8;
			            if (l>=270 && l<=340)
			            {
			            	if (k>=50 && k<=120)
			            	{
			            		i = 0; 
			            		j = 0;
			            	}
			            	else if (k>=145 && k<=215)
			            	{
			            		i = 0;
			            		j = 1;
			            	}
			            	else if (k>=240 && k<=310)
			            	{
			            		i = 0;
			            		j = 2;
			            	}
			            	else if (k>=335 && k<=405)
			            	{
			            		i = 0;
			            		j = 3;
			            	}
			            	else if (k>=430 && k<=500)
			            	{
			            		i = 0;
			            		j = 4;
			            	}
			            }
			            else if (l>=365 && l<=435)
			            {
			            	if (k>=50 && k<=120)
			            	{
			            		i = 1; 
			            		j = 0;
			            	}
			            	else if (k>=145 && k<=215)
			            	{
			            		i = 1;
			            		j = 1;
			            	}
			            	else if (k>=240 && k<=310)
			            	{
			            		i = 1;
			            		j = 2;
			            	}
			            	else if (k>=335 && k<=405)
			            	{
			            		i = 1;
			            		j = 3;
			            	}
			            	else if (k>=430 && k<=500)
			            	{
			            		i = 1;
			            		j = 4;
			            	}
			            }
			            else if (l>=460 && l<=530)
			            {
			            	if (k>=50 && k<=120)
			            	{
			            		i = 2; 
			            		j = 0;
			            	}
			            	else if (k>=145 && k<=215)
			            	{
			            		i = 2;
			            		j = 1;
			            	}
			            	else if (k>=240 && k<=310)
			            	{
			            		i = 2;
			            		j = 2;
			            	}
			            	else if (k>=335 && k<=405)
			            	{
			            		i = 2;
			            		j = 3;
			            	}
			            	else if (k>=430 && k<=500)
			            	{
			            		i = 2;
			            		j = 4;
			            	}
			            }
			            else if (l>=555 && l<=625)
			            {
			            	if (k>=50 && k<=120)
			            	{
			            		i = 3; 
			            		j = 0;
			            	}
			            	else if (k>=145 && k<=215)
			            	{
			            		i = 3;
			            		j = 1;
			            	}
			            	else if (k>=240 && k<=310)
			            	{
			            		i = 3;
			            		j = 2;
			            	}
			            	else if (k>=335 && k<=405)
			            	{
			            		i = 3;
			            		j = 3;
			            	}
			            	else if (k>=430 && k<=500)
			            	{
			            		i = 3;
			            		j = 4;
			            	}
			            }
			            else if (l>=650 && l<=720)
			            {
			            	if (k>=50 && k<=120)
			            	{
			            		i = 4; 
			            		j = 0;
			            	}
			            	else if (k>=145 && k<=215)
			            	{
			            		i = 4;
			            		j = 1;
			            	}
			            	else if (k>=240 && k<=310)
			            	{
			            		i = 4;
			            		j = 2;
			            	}
			            	else if (k>=335 && k<=405)
			            	{
			            		i = 4;
			            		j = 3;
			            	}
			            	else if (k>=430 && k<=500)
			            	{
			            		i = 4;
			            		j = 4;
			            	}
			            }

		                     
			          //Si deseleccionamos la casilla seleccionada
			            if(seleccionada_posi == i && seleccionada_posj == j)
			            {
			                if(flagSalto)
			                {
			                	for (int a=15; a>0; a--)
			                	{
			                		if (saltos[a] != -1)
			                		{
			                			borrarCuadro(saltos[a]%5, saltos[a]/5);
			                		}
			                	}
			                }
	            	
			            	borrarCuadro(i, j);
			                borrarCuadro (candidata_posi, candidata_posj);
			                pintarPieza(tablero.casillas[asociaCasilla(i,j)].numjugador, j, i, true);
			              
			                seleccionada_posj = -1;
			                seleccionada_posi = -1;	
			                candidata_posi = -1;
			                candidata_posj = -1;
			                
			                inicializaSaltos();
			                
			                saltos[0]= -1;
			                sal_borra[0] = -1;
			                vector_aux[0]=-1;
			                
			                break label0;
			            }            
	            
			            //Cuando seleccionamos
			            if(seleccionada_posi == -1 && seleccionada_posj == -1)
			            {	
			            	if (i>4 && j >4)
			            	{
			            		break label0;
			            	}
			            	//Si pinchamos en una casilla sin ficha (sin que haya nada seleccionado)
			            	if (tablero.casillas[asociaCasilla(i,j)].ocupado == false)
			                    break label0;
		            	
			            	//Si pinchamos para seleccionar en una ficha cuyo turno no corresponde
			            	if(tablero.casillas[asociaCasilla(i,j)].numjugador != turno)
			            		break label0;
		            	
			                seleccionada_posi = i;
			                seleccionada_posj = j;
		                               
		                
			                //Para comenzar el tiempo la primera vez que pinchemos
			                if(cuentaEmpezar==0)
			                {	
			                	cuentaEmpezar = 1;
			                	tiempo.start();
			                }
			              
			                dibujaSeleccion(i, j);
			                
			                saltos[0] = asociaCasilla(seleccionada_posi, seleccionada_posj); 
			                //System.out.println("buaahh " + saltos[0]);
			            }
			            
			            else //Caso en el que haya una ficha seleccionada y pincha en otra casilla 
			            {
			            	if (i>7 && j >7)
			            	{
			            		if(flagSalto)
				                {
				                	for (int a=15; a>0; a--)
				                	{
				                		if (saltos[a] != -1)
				                		{
				                			borrarCuadro(saltos[a]%7, saltos[a]/7);
				                		}
				                	}
				                }
		            	
				            	borrarCuadro(i, j);
				                borrarCuadro (candidata_posi, candidata_posj);
				                borrarCuadro (i, j);
				                pintarPieza(tablero.casillas[XasociaCasilla(seleccionada_posi,seleccionada_posj)].numjugador, seleccionada_posj, seleccionada_posi, true);
				                seleccionada_posj = -1;
				                seleccionada_posi = -1;	
				                inicializaSaltos();
				                saltos[0]= -1;
				                sal_borra[0] = -1;
				                vector_aux[0]=-1;
			            		break label0;
			            	}
			            	if(seleccionada_posi != i || seleccionada_posj != j)
			            	{            		
			             	 	if(tablero.casillas[asociaCasilla(i,j)].ocupado == false)
			             	 	{ 
	//Se activa cuando hay posibilidad de movimiento (espera un nuevo click a esa posicion para ejecutar el cambio)
	             	 	            flag = false;
			             	 	    numCasillaCandidata = asociaCasilla(i, j);
			         	 			numCasillaSeleccionada = asociaCasilla(seleccionada_posi, seleccionada_posj);
			         	 			if (saltos[0] == -1)
			         	 			{
			         	 				saltos[0] = numCasillaSeleccionada; //La casilla seleccionada de verdad
			         	 				System.out.println("la casilla d verdad " + saltos[0]);
			         	 			}
	         	 			
			         	 			if(tablero.casillas[numCasillaSeleccionada].numjugador == 1)
			         	 			{
			         	 				//Tratamos el movimiento simple (para el jugador 1)
			         	 				if (Cinco.adyacentes[numCasillaSeleccionada][0] == numCasillaCandidata)
			         	 				{
			         	 					for (int a=15; a>0; a--)
			         	 					{
			         	 						if (saltos[a] != -1)
			         	 						{
			         	 							borrarCuadro(saltos[a]%5, saltos[a]/5);
			         	 						}
			         	 					}
			                 	 			flag = true;
			                 	 			flagSalto = false;
			                 	 			inicializaSaltos();
			         	 				}
			         	 				else
			         	 					if (Cinco.adyacentes[numCasillaSeleccionada][1] == numCasillaCandidata)
				         	 				{
				         	 					for (int a=15; a>0; a--)
				         	 					{
				         	 						if (saltos[a] != -1)
				         	 						{
				         	 							borrarCuadro(saltos[a]%5, saltos[a]/5);
				         	 						}
				         	 					}
				                 	 			flag = true;
				                 	 			flagSalto = false;
				                 	 			inicializaSaltos();
				         	 				}
			         	 					else
			         	 						if (Cinco.adyacentes[numCasillaSeleccionada][2] == numCasillaCandidata)
					         	 				{
					         	 					for (int a=15; a>0; a--)
					         	 					{
					         	 						if (saltos[a] != -1)
					         	 						{
					         	 							borrarCuadro(saltos[a]%5, saltos[a]/5);
					         	 						}
					         	 					}
					                 	 			flag = true;
					                 	 			flagSalto = false;
					                 	 			inicializaSaltos();
					         	 				}
			         	 						else
			         	 				
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
			         	 				
			         	 				
			         	 				
			         	 				if (Cinco.adyacentes[numCasillaSeleccionada][3] == numCasillaCandidata)
			         	 				{
			         	 					for (int a=15; a>0; a--)
			         	 					{
			         	 						if (saltos[a] != -1)
			         	 						{
			         	 							borrarCuadro(saltos[a]%5, saltos[a]/5);
			         	 						}
			         	 					}
			                 	 			flag = true;
			                 	 			flagSalto = false;
			                 	 			inicializaSaltos();
			         	 				}
			         	 				
			         	 				else 
			         	 					if (Cinco.adyacentes[numCasillaSeleccionada][4] == numCasillaCandidata)
			         	 					{
			         	 						for (int a=15; a>0; a--)
			         	 						{
			         	 							if (saltos[a] != -1)
			         	 							{
			         	 								borrarCuadro(saltos[a]%5, saltos[a]/5);
			         	 							}
			         	 						}
			         	 						flag = true;
			         	 						flagSalto = false;
			         	 						inicializaSaltos();
			         	 					}
			         	 					else 
			         	 						if (Cinco.adyacentes[numCasillaSeleccionada][5] == numCasillaCandidata)
			         	 						{
			         	 							for (int a=15; a>0; a--)
			         	 							{
			         	 								if (saltos[a] != -1)
			         	 								{
			         	 									borrarCuadro(saltos[a]%5, saltos[a]/5);
			         	 								}
			         	 							}
			         	 							flag = true;
			         	 							flagSalto = false;
			         	 							inicializaSaltos();
			         	 						}
			         	 						else 
			         	 							if (Cinco.adyacentes[numCasillaSeleccionada][6] == numCasillaCandidata)
			         	 							{
			         	 								for (int a=15; a>0; a--)
			         	 								{
			         	 									if (saltos[a] != -1)
			         	 									{
			         	 										borrarCuadro(saltos[a]%5, saltos[a]/5);
			         	 									}
			         	 								}
			         	 								flag = true;
			         	 								flagSalto = false;
			         	 								inicializaSaltos();
			         	 							}
			         	 							else 
			         	 								if (Cinco.adyacentes[numCasillaSeleccionada][7] == numCasillaCandidata)
			         	 								{
			         	 									for (int a=15; a>0; a--)
			         	 									{
			         	 										if (saltos[a] != -1)
			         	 										{
			         	 											borrarCuadro(saltos[a]%5, saltos[a]/5);
			         	 										}
			         	 									}
			         	 									flag = true;
			         	 									flagSalto = false;
			         	 									inicializaSaltos();
			         	 								}
	             	 			
			         	 			}
	          	 		
			         	 			else 
			         	 				if(tablero.casillas[numCasillaSeleccionada].numjugador == 2)
			         	 				{
	             	 			//Tratamos el movimiento simple (para el jugador 2)
	             	 			
			         	 					if (Cinco.adyacentes[numCasillaSeleccionada][0] == numCasillaCandidata)
			         	 					{
			         	 						for (int a=15; a>0; a--)
			         	 						{
			         	 							if (saltos[a] != -1)
			         	 							{
			         	 								borrarCuadro(saltos[a]%5, saltos[a]/5);
			         	 							}
			         	 						}
			         	 						flag = true;
			         	 						flagSalto = false;
			         	 						inicializaSaltos();
			         	 					}
			         	 					else 
			         	 						if (Cinco.adyacentes[numCasillaSeleccionada][1] == numCasillaCandidata)
			         	 						{
			         	 							for (int a=15; a>0; a--)
			         	 							{
			         	 								if (saltos[a] != -1)
			         	 								{
			         	 									borrarCuadro(saltos[a]%5, saltos[a]/5);
			         	 								}
			         	 							}
			         	 							flag = true;
			         	 							flagSalto = false;
			         	 							inicializaSaltos();
			         	 						}
			         	 						else 
			         	 							if (Cinco.adyacentes[numCasillaSeleccionada][2] == numCasillaCandidata)
			         	 							{
			         	 								for (int a=15; a>0; a--)
			         	 								{
			         	 									if (saltos[a] != -1)
			         	 									{
			         	 										borrarCuadro(saltos[a]%5, saltos[a]/5);
			         	 									}
			         	 								}
			         	 								flag = true;
			         	 								flagSalto = false;
			         	 								inicializaSaltos();
			         	 							}
			         	 							else 
			         	 								if (Cinco.adyacentes[numCasillaSeleccionada][3] == numCasillaCandidata)
			         	 								{
			         	 									for (int a=15; a>0; a--)
			         	 									{
			         	 										if (saltos[a] != -1)
			         	 										{
			         	 											borrarCuadro(saltos[a]%5, saltos[a]/5);
			         	 										}
			         	 									}
			         	 									flag = true;
			         	 									flagSalto = false;
			         	 									inicializaSaltos();
			         	 								}
			         	 								else 
			         	 									if (Cinco.adyacentes[numCasillaSeleccionada][4] == numCasillaCandidata)
			         	 									{
			         	 										for (int a=15; a>0; a--)
			         	 										{
			         	 											if (saltos[a] != -1)
			         	 											{
			         	 												borrarCuadro(saltos[a]%5, saltos[a]/5);
			         	 											}
			         	 										}
			         	 										flag = true;
			         	 										flagSalto = false;
			         	 										inicializaSaltos();
			         	 									}
			         	 									else 
				         	 									if (Cinco.adyacentes[numCasillaSeleccionada][5] == numCasillaCandidata)
				         	 									{
				         	 										for (int a=15; a>0; a--)
				         	 										{
				         	 											if (saltos[a] != -1)
				         	 											{
				         	 												borrarCuadro(saltos[a]%5, saltos[a]/5);
				         	 											}
				         	 										}
				         	 										flag = true;
				         	 										flagSalto = false;
				         	 										inicializaSaltos();
				         	 									}
				         	 									else 
					         	 									if (Cinco.adyacentes[numCasillaSeleccionada][6] == numCasillaCandidata)
					         	 									{
					         	 										for (int a=15; a>0; a--)
					         	 										{
					         	 											if (saltos[a] != -1)
					         	 											{
					         	 												borrarCuadro(saltos[a]%5, saltos[a]/5);
					         	 											}
					         	 										}
					         	 										flag = true;
					         	 										flagSalto = false;
					         	 										inicializaSaltos();
					         	 									}
					         	 									else 
						         	 									if (Cinco.adyacentes[numCasillaSeleccionada][7] == numCasillaCandidata)
						         	 									{
						         	 										for (int a=15; a>0; a--)
						         	 										{
						         	 											if (saltos[a] != -1)
						         	 											{
						         	 												borrarCuadro(saltos[a]%5, saltos[a]/5);
						         	 											}
						         	 										}
						         	 										flag = true;
						         	 										flagSalto = false;
						         	 										inicializaSaltos();
						         	 									}
			         	 	////////////////////////////////////////////////////////////////////////////////////////////////////////////				
			         	 					
			         	 					//Tratamos la situacion de un salto (para el jugador 2)
	             	 			
			         	 				if (Cinco.adyacentes[saltos[0]][0] != -1 &&
			         	 						tablero.casillas[asociaCasilla(Cinco.adyacentes[saltos[0]][0]%5,Cinco.adyacentes[saltos[0]][0]/5)].ocupado == true &&
			         	 						Cinco.adyacentes[Cinco.adyacentes[saltos[0]][0]][0] == numCasillaCandidata)
			         	 				{
			         	 					sal_borra[numsalto] = asociaCasilla(Cinco.adyacentes[saltos[numsalto]][0]%5,Cinco.adyacentes[saltos[numsalto]][0]/5);
			         	 					flag = true;
			         	 					if (Cinco.adyacentes[saltos[0]][0] != -1 &&
			         	 						tablero.casillas[asociaCasilla(Cinco.adyacentes[saltos[0]][0]%5,Cinco.adyacentes[saltos[0]][0]/5)].ocupado == true &&
			         	 						Cinco.adyacentes[Cinco.adyacentes[saltos[0]][0]][0] == numCasillaCandidata)
			         	 					{
			         	 						for (int a=15; a>0; a--)
			         	 						{
			         	 							if (saltos[a] != -1)
			         	 							{
			         	 								borrarCuadro(saltos[a]%5, saltos[a]/5);
			         	 							}
			         	 						}
			         	 						inicializaSaltos();
			         	 					}
			         	 					else
			         	 						if (flagSalto == false)
			         	 						{
			         	 							inicializaSaltos();
			         	 						}
			         	 						flagSalto = true;
			         	 						numsalto++; //Aumentamos en uno el numero de salto
			         	 						saltos[numsalto] = numCasillaCandidata;
			         	 				}
			         	 				else 
			         	 					if (Cinco.adyacentes[saltos[0]][1] != -1 &&
			         	 							tablero.casillas[asociaCasilla(Cinco.adyacentes[saltos[0]][1]%5,Cinco.adyacentes[saltos[0]][1]/5)].ocupado == true &&
			         	 							Cinco.adyacentes[Cinco.adyacentes[saltos[0]][1]][1] == numCasillaCandidata)
			         	 					{
			         	 						sal_borra[numsalto] = asociaCasilla(Cinco.adyacentes[saltos[numsalto]][1]%5,Cinco.adyacentes[saltos[numsalto]][1]/5);
			         	 						flag = true;
			         	 						if (Cinco.adyacentes[saltos[0]][1] != -1 &&
			         	 								tablero.casillas[asociaCasilla(Cinco.adyacentes[saltos[0]][1]%5,Cinco.adyacentes[saltos[0]][1]/5)].ocupado == true &&
			         	 								Cinco.adyacentes[Cinco.adyacentes[saltos[0]][1]][1] == numCasillaCandidata)
			         	 						{
			         	 							for (int a=15; a>0; a--)
			         	 							{
			         	 								if (saltos[a] != -1)
			         	 								{
			         	 									borrarCuadro(saltos[a]%5, saltos[a]/5);
			         	 								}
			         	 							}
			         	 							inicializaSaltos();
			         	 						}
			         	 						else 
			         	 							if (flagSalto == false)
			         	 							{
			         	 								inicializaSaltos();
			         	 							}
			         	 							flagSalto = true;
			         	 							numsalto++; //Aumentamos en uno el numero de salto
			         	 							saltos[numsalto] = numCasillaCandidata;
			         	 					}
			         	 					else 
			         	 						if (Cinco.adyacentes[saltos[0]][2] != -1 &&
			         	 								tablero.casillas[asociaCasilla(Cinco.adyacentes[saltos[0]][2]%5,Cinco.adyacentes[saltos[0]][2]/5)].ocupado == true &&
			         	 								Cinco.adyacentes[Cinco.adyacentes[saltos[0]][2]][2] == numCasillaCandidata)
			         	 						{
			         	 							sal_borra[numsalto] = asociaCasilla(Cinco.adyacentes[saltos[numsalto]][2]%5,Cinco.adyacentes[saltos[numsalto]][2]/5);
			         	 							flag = true;
			         	 							if (Cinco.adyacentes[saltos[0]][2] != -1 &&
			         	 									tablero.casillas[asociaCasilla(Cinco.adyacentes[saltos[0]][2]%5,Cinco.adyacentes[saltos[0]][2]/5)].ocupado == true &&
			         	 									Cinco.adyacentes[Cinco.adyacentes[saltos[0]][2]][2] == numCasillaCandidata)
			         	 							{
			         	 								for (int a=15; a>0; a--)
			         	 								{
			         	 									if (saltos[a] != -1)
			         	 									{
			         	 										borrarCuadro(saltos[a]%5, saltos[a]/5);
			         	 									}
			         	 								}
			         	 								inicializaSaltos();
			         	 							}
			         	 							else 
			         	 								if (flagSalto == false)
			         	 								{
			         	 									inicializaSaltos();
			         	 								}
			         	 								flagSalto = true;
			         	 								numsalto++; //Aumentamos en uno el numero de salto
			         	 								saltos[numsalto] = numCasillaCandidata;
			         	 						}
			         	 						else 
			         	 							if (Cinco.adyacentes[saltos[0]][3] != -1 &&
			         	 									tablero.casillas[asociaCasilla(Cinco.adyacentes[saltos[0]][3]%5,Cinco.adyacentes[saltos[0]][3]/5)].ocupado == true &&
			         	 									Cinco.adyacentes[Cinco.adyacentes[saltos[0]][3]][3] == numCasillaCandidata)
			         	 							{
			         	 								System.out.println("Saltos 0 vale " + saltos[0]);
			         	 								System.out.println("Saltos numsalto vale " + saltos[numsalto]);
			         	 								System.out.println("el %16 vale " + Cinco.adyacentes[saltos[numsalto]][3]%5 + " y el /16 vale " + Cinco.adyacentes[saltos[numsalto]][3]/5);
			         	 								
			         	 								sal_borra[numsalto] = asociaCasilla(Cinco.adyacentes[saltos[numsalto]][3]%5,Cinco.adyacentes[saltos[numsalto]][3]/5);
			         	 								System.out.println("El valor de sal_borra[0] es " + sal_borra[0]);
			         	 								System.out.println("num salto vale " + numsalto);
			         	 								flag = true;
			         	 								if (Cinco.adyacentes[saltos[0]][3] != -1 &&
			         	 										tablero.casillas[asociaCasilla(Cinco.adyacentes[saltos[0]][3]%5,Cinco.adyacentes[saltos[0]][3]/5)].ocupado == true &&
			         	 										Cinco.adyacentes[Cinco.adyacentes[saltos[0]][3]][3] == numCasillaCandidata)
			         	 								{
			         	 									for (int a=15; a>0; a--)
			         	 									{
			         	 										if (saltos[a] != -1)
			         	 										{
			         	 											borrarCuadro(saltos[a]%5, saltos[a]/5);
			         	 										}
			         	 			        				}
			         	 									inicializaSaltos();
			         	 								}
			         	 								else 
			         	 									if (flagSalto == false)
			         	 									{
			         	 										inicializaSaltos();
			         	 									}
			         	 									flagSalto = true;
			         	 									numsalto++; //Aumentamos en uno el numero de salto
			         	 									saltos[numsalto] = numCasillaCandidata;
			         	 							}
			         	 							else
			         	 								if (Cinco.adyacentes[saltos[0]][4] != -1 &&
			         	 										tablero.casillas[asociaCasilla(Cinco.adyacentes[saltos[0]][4]%5,Cinco.adyacentes[saltos[0]][4]/5)].ocupado == true &&
			         	 										Cinco.adyacentes[Cinco.adyacentes[saltos[0]][4]][4] == numCasillaCandidata)
			         	 								{
			         	 									sal_borra[numsalto] = asociaCasilla(Cinco.adyacentes[saltos[numsalto]][4]%5,Cinco.adyacentes[saltos[numsalto]][4]/5);
			         	 									flag = true;
			         	 									if (Cinco.adyacentes[saltos[0]][4] != -1 &&
			         	 											tablero.casillas[asociaCasilla(Cinco.adyacentes[saltos[0]][4]%5,Cinco.adyacentes[saltos[0]][4]/5)].ocupado == true &&
			         	 											Cinco.adyacentes[Cinco.adyacentes[saltos[0]][4]][4] == numCasillaCandidata)
			         	 									{
			         	 										for (int a=15; a>0; a--)
			         	 										{
			         	 											if (saltos[a] != -1)
			         	 											{
			         	 												borrarCuadro(saltos[a]%5, saltos[a]/5);
			         	 											}
			         	 										}
			         	 										inicializaSaltos();
			         	 									}
			         	 									else 
			         	 										if (flagSalto == false)
			         	 										{
			         	 											inicializaSaltos();
			         	 										}
			         	 										flagSalto = true;
			         	 										numsalto++; //Aumentamos en uno el numero de salto
			         	 										saltos[numsalto] = numCasillaCandidata;
			         	 								}
			         	 								else
				         	 								if (Cinco.adyacentes[saltos[0]][5] != -1 &&
				         	 										tablero.casillas[asociaCasilla(Cinco.adyacentes[saltos[0]][5]%5,Cinco.adyacentes[saltos[0]][5]/5)].ocupado == true &&
				         	 										Cinco.adyacentes[Cinco.adyacentes[saltos[0]][5]][5] == numCasillaCandidata)
				         	 								{
				         	 									sal_borra[numsalto] = asociaCasilla(Cinco.adyacentes[saltos[numsalto]][5]%5,Cinco.adyacentes[saltos[numsalto]][5]/5);
				         	 									flag = true;
				         	 									if (Cinco.adyacentes[saltos[0]][5] != -1 &&
				         	 											tablero.casillas[asociaCasilla(Cinco.adyacentes[saltos[0]][5]%5,Cinco.adyacentes[saltos[0]][5]/5)].ocupado == true &&
				         	 											Cinco.adyacentes[Cinco.adyacentes[saltos[0]][5]][5] == numCasillaCandidata)
				         	 									{
				         	 										for (int a=15; a>0; a--)
				         	 										{
				         	 											if (saltos[a] != -1)
				         	 											{
				         	 												borrarCuadro(saltos[a]%5, saltos[a]/5);
				         	 											}
				         	 										}
				         	 										inicializaSaltos();
				         	 									}
				         	 									else 
				         	 										if (flagSalto == false)
				         	 										{
				         	 											inicializaSaltos();
				         	 										}
				         	 										flagSalto = true;
				         	 										numsalto++; //Aumentamos en uno el numero de salto
				         	 										saltos[numsalto] = numCasillaCandidata;
				         	 								}
			         	 				
				         	 								else
					         	 								if (Cinco.adyacentes[saltos[0]][6] != -1 &&
					         	 										tablero.casillas[asociaCasilla(Cinco.adyacentes[saltos[0]][6]%5,Cinco.adyacentes[saltos[0]][6]/5)].ocupado == true &&
					         	 										Cinco.adyacentes[Cinco.adyacentes[saltos[0]][6]][6] == numCasillaCandidata)
					         	 								{
					         	 									sal_borra[numsalto] = asociaCasilla(Cinco.adyacentes[saltos[numsalto]][6]%5,Cinco.adyacentes[saltos[numsalto]][6]/5);
					         	 									flag = true;
					         	 									if (Cinco.adyacentes[saltos[0]][6] != -1 &&
					         	 											tablero.casillas[asociaCasilla(Cinco.adyacentes[saltos[0]][6]%5,Cinco.adyacentes[saltos[0]][6]/5)].ocupado == true &&
					         	 											Cinco.adyacentes[Cinco.adyacentes[saltos[0]][6]][6] == numCasillaCandidata)
					         	 									{
					         	 										for (int a=15; a>0; a--)
					         	 										{
					         	 											if (saltos[a] != -1)
					         	 											{
					         	 												borrarCuadro(saltos[a]%5, saltos[a]/5);
					         	 											}
					         	 										}
					         	 										inicializaSaltos();
					         	 									}
					         	 									else 
					         	 										if (flagSalto == false)
					         	 										{
					         	 											inicializaSaltos();
					         	 										}
					         	 										flagSalto = true;
					         	 										numsalto++; //Aumentamos en uno el numero de salto
					         	 										saltos[numsalto] = numCasillaCandidata;
					         	 								}
					         	 								else
						         	 								if (Cinco.adyacentes[saltos[0]][7] != -1 &&
						         	 										tablero.casillas[asociaCasilla(Cinco.adyacentes[saltos[0]][7]%5,Cinco.adyacentes[saltos[0]][7]/5)].ocupado == true &&
						         	 										Cinco.adyacentes[Cinco.adyacentes[saltos[0]][7]][7] == numCasillaCandidata)
						         	 								{
						         	 									sal_borra[numsalto] = asociaCasilla(Cinco.adyacentes[saltos[numsalto]][7]%5,Cinco.adyacentes[saltos[numsalto]][7]/5);
						         	 									flag = true;
						         	 									if (Cinco.adyacentes[saltos[0]][7] != -1 &&
						         	 											tablero.casillas[asociaCasilla(Cinco.adyacentes[saltos[0]][7]%5,Cinco.adyacentes[saltos[0]][7]/5)].ocupado == true &&
						         	 											Cinco.adyacentes[Cinco.adyacentes[saltos[0]][7]][7] == numCasillaCandidata)
						         	 									{
						         	 										for (int a=15; a>0; a--)
						         	 										{
						         	 											if (saltos[a] != -1)
						         	 											{
						         	 												borrarCuadro(saltos[a]%5, saltos[a]/5);
						         	 											}
						         	 										}
						         	 										inicializaSaltos();
						         	 									}
						         	 									else 
						         	 										if (flagSalto == false)
						         	 										{
						         	 											inicializaSaltos();
						         	 										}
						         	 										flagSalto = true;
						         	 										numsalto++; //Aumentamos en uno el numero de salto
						         	 										saltos[numsalto] = numCasillaCandidata;
						         	 								}
			         	 				
			         	 	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
			         	 				
	             	 			
			         	 				}
	                    
			         	 			if (flagSalto && flag)
			         	 			{
			         	 				if (numsalto == 1) //Para borrar las selecciones cuando se pivota con casillaSeleccionada
			         	 				{
			         	 					//System.out.println(numsalto);
			         	 					borrarCuadro (candidata_posi, candidata_posj);
			         	 				}
			         	 				candidata_posi = i;
			         	 				candidata_posj = j;
			         	 				dibujaCandidata(i,j);
			         	 				dibujaSeleccion(saltos[0]%5, saltos[0]/5);
			         	 				//System.out.println("salto???");
			         	 			}
	         	 			
			         	 			if(flag)
			         	 			{
	                			//Entramos aqui si ya esta seleccionada la posicion a la que
	                			//queremos mover y se esta esperando otro click ahi
	                			
	             	 			               			
	             	 		//hay ya una casilla seleccionada y la tenemos que quitar
			         	 				if (candidata_posi != -1 && candidata_posj != -1)
			         	 				{
			         	 					borrarCuadro (candidata_posi, candidata_posj);
			         	 					
			         	 				}
	                			
			         	 				candidata_posi = i;
			         	 				candidata_posj = j;
			         	 				dibujaCandidata(i,j);
			         	 				dibujaSeleccion(saltos[0]%5, saltos[0]/5);
			         	 				//System.out.println("JAVIsdfgsdf");
			         	 			}
			         	 			else
			         	 			{
			         	 				//Si el flag no esta activo no se hace nada (no hay seleccion ninguna)
			         	 			}
			             	 	}	
	             	 	
			            	}
	            }}
	    	}
	    	
		
	    	else  //caso en el que hacemos doble click
	    	{
	    		if(mouseevent.getClickCount()==2)
	    		{
	    			//System.out.println("JAVI");
	    			Graphics2D graphics2d = (Graphics2D)getGraphics();
	    			int l = mouseevent.getX();
	    			int k = mouseevent.getY();
	    			//if(l <= 20 || l >= 660 || k <=50 || k >= 690)
	    			//if(l <= 200 || l >= 800 || k <=50 || k >= 690)
	    			if(l <= 270 || l >= 720 || k <=50 || k >= 500)    
	    			{
	    				break label0;
	    			}
	            
	    			//int i = Math.round((l-20) / 80);
	    			//int i = Math.round((l-20) / 80);
	            	//int i = Math.round((l-200) / 80);
		           // int j = Math.round((k-50) / 80);
		            int i = 8, j = 8;
		            if (l>=270 && l<=340)
		            {
		            	if (k>=50 && k<=120)
		            	{
		            		i = 0; 
		            		j = 0;
		            	}
		            	else if (k>=145 && k<=215)
		            	{
		            		i = 0;
		            		j = 1;
		            	}
		            	else if (k>=240 && k<=310)
		            	{
		            		i = 0;
		            		j = 2;
		            	}
		            	else if (k>=335 && k<=405)
		            	{
		            		i = 0;
		            		j = 3;
		            	}
		            	else if (k>=430 && k<=500)
		            	{
		            		i = 0;
		            		j = 4;
		            	}
		            }
		            else if (l>=365 && l<=435)
		            {
		            	if (k>=50 && k<=120)
		            	{
		            		i = 1; 
		            		j = 0;
		            	}
		            	else if (k>=145 && k<=215)
		            	{
		            		i = 1;
		            		j = 1;
		            	}
		            	else if (k>=240 && k<=310)
		            	{
		            		i = 1;
		            		j = 2;
		            	}
		            	else if (k>=335 && k<=405)
		            	{
		            		i = 1;
		            		j = 3;
		            	}
		            	else if (k>=430 && k<=500)
		            	{
		            		i = 1;
		            		j = 4;
		            	}
		            }
		            else if (l>=460 && l<=530)
		            {
		            	if (k>=50 && k<=120)
		            	{
		            		i = 2; 
		            		j = 0;
		            	}
		            	else if (k>=145 && k<=215)
		            	{
		            		i = 2;
		            		j = 1;
		            	}
		            	else if (k>=240 && k<=310)
		            	{
		            		i = 2;
		            		j = 2;
		            	}
		            	else if (k>=335 && k<=405)
		            	{
		            		i = 2;
		            		j = 3;
		            	}
		            	else if (k>=430 && k<=500)
		            	{
		            		i = 2;
		            		j = 4;
		            	}
		            }
		            else if (l>=555 && l<=625)
		            {
		            	if (k>=50 && k<=120)
		            	{
		            		i = 3; 
		            		j = 0;
		            	}
		            	else if (k>=145 && k<=215)
		            	{
		            		i = 3;
		            		j = 1;
		            	}
		            	else if (k>=240 && k<=310)
		            	{
		            		i = 3;
		            		j = 2;
		            	}
		            	else if (k>=335 && k<=405)
		            	{
		            		i = 3;
		            		j = 3;
		            	}
		            	else if (k>=430 && k<=500)
		            	{
		            		i = 3;
		            		j = 4;
		            	}
		            }
		            else if (l>=650 && l<=720)
		            {
		            	if (k>=50 && k<=120)
		            	{
		            		i = 4; 
		            		j = 0;
		            	}
		            	else if (k>=145 && k<=215)
		            	{
		            		i = 4;
		            		j = 1;
		            	}
		            	else if (k>=240 && k<=310)
		            	{
		            		i = 4;
		            		j = 2;
		            	}
		            	else if (k>=335 && k<=405)
		            	{
		            		i = 4;
		            		j = 3;
		            	}
		            	else if (k>=430 && k<=500)
		            	{
		            		i = 4;
		            		j = 4;
		            	}
		            }
	                        
	    			
	            //caso en el que no haya ninguna casilla seleccionada
	            if(seleccionada_posi == -1 && seleccionada_posj == -1)	
	            {
	            	break label0;
	            }
	            
	            //Habiendo una seleccionada, hacemos doble click en otra casilla
	    		if(seleccionada_posi != i || seleccionada_posj != j)
	            {
	    			borrarCuadro (candidata_posi, candidata_posj); // Para evitar que se quede una casilla candidata
	    							//dibujada cuando se hace un doble click incorrecto
	    			
	    			//actualizamos los indices de la casilla seleccionada
	    			candidata_posi = i;
	    			candidata_posj = j;
	    		
	    			if(flag)//se puede realizar el movimiento
	              	{
	    				if(!flagSalto)
	    				{
	    					for (int a=0; a<16; a++)
	                        {
	                        	if (saltos[a] != -1)
	                        	{
	                        		borrarCuadro(saltos[a]%5, saltos[a]/5);
	                        	}
	                        }
	    				}
	    				
	    				numCasillaSeleccionada = asociaCasilla(seleccionada_posi, seleccionada_posj);
	    				numCasillaCandidata = asociaCasilla(candidata_posi, candidata_posj);
	    				dibujaCandidata(i,j);
	    				numsalto = 0;
	    				if(flagSalto)
	                    {
	    					
	                    	for (int a=1; a<16; a++)
	                    	{
	                    		if (saltos[a-1] != -1 && saltos[a] != -1)
	                    		{
	                    			borrarCuadro(saltos[a-1]%5, saltos[a-1]/5);
	                    			parpadeo();
	                    			borrarCuadro(sal_borra[a-1]%5, sal_borra[a-1]/5);
	                    			pintarPieza(tablero.casillas[numCasillaSeleccionada].numjugador, saltos[a]/5, saltos[a]%5, true);
	                    			//borrarCuadro(sal_borra[a-1]%5, sal_borra[a-1]/5);
	                    			numsalto++;
	                    			
	                    			parpadeo(); //Relentiza el proceso de dibujar los saltos
	                    			
	                    		}
	                    	}
	                    }
	                  
	    				borrarCuadro(seleccionada_posi, seleccionada_posj);
	    				
	    				//casilla_borrar = asociaCasilla(sal_borra[0]%5, sal_borra[0]/5);
	    				
	    				for (int a=0; a<16; a++)
	    				{
	    					//System.out.print(asociaCasilla(sal_borra[a]%5,sal_borra[a]/5) + ", ");
	    					if (sal_borra[a] != -1)
	    						vector_aux [a] = asociaCasilla(sal_borra[a]%5, sal_borra[a]/5);
	    				}
	    				/*
	    				for (int a=0; a<16; a++)
	    					if (sal_borra[a] != -1)
	    						borrarCuadro(sal_borra[a]%5, sal_borra[a]/5);
	                	*/
	    				pintarPieza(tablero.casillas[numCasillaSeleccionada].numjugador, candidata_posj, candidata_posi, true);
	    				
	
	///////////////////////////////////    				///////////////////////////////
	                    //mover(numCasillaSeleccionada, numCasillaCandidata, casilla_borrar);
	                    mover(numCasillaSeleccionada, numCasillaCandidata, vector_aux);
	                    for (int a = 0; a<16;a++){
	                    	vector_aux[a] = -1;
	                    	sal_borra[a] = -1;
	                    }
	     ////////////////////////////////////////////////                    /////////////////////////////
	                    if(compruebaGanador()!=0)
	                    {
	                    	detenerJuego = true;
	                    	muestraGanador();
	                    }
	                    
	                    seleccionada_posj = -1;
	                    seleccionada_posi = -1;	
	                    candidata_posi = -1;
	                    candidata_posj = -1;
	                    inicializaSaltos();
	                    saltos[0]= -1; //Desanclamos el numCasillaSeleccionada, ya se se mueve la ficha
	                    flagSalto =false;
	                    flag = false;
	                    numsalto = 0;
	                    if(tablero.jugadores[turno-1].esPC && !detenerJuego)
	            		{
	            			mover_pc();
	            		}
	                    
	                    break label0;
	              	}
	              	else //no se puede realizar el movimiento
	              	{
	              		lAviso.setText("¡ERROR! El movimiento es incorrecto, no se puede realizar");
	              		
	              	}          	  
	      
	    	  		}
	    		}
	   
	    	}
			}//fin tipotabl == 1
		 	if (tipotabl == 4)
			{
			 	if(tablero.jugadores[turno-1].esPC && cuentaEmpezar==0)
			 	{
			 		cuentaEmpezar = 1;
		        	tiempo.start();
			 	}	 	
	    	
	    	//caso en el que hacemos un solo click
			 	if(mouseevent.getClickCount() == 1)
		    	{    		
		    		Graphics2D graphics2d = (Graphics2D)getGraphics();
		            int l = mouseevent.getX();
		            int k = mouseevent.getY();
		            
		            //if(l <= 20 || l >= 660 || k <=50 || k >= 690)
		            //if(l <= 200 || l >= 800 || k <=50 || k >= 690)
		            if(l <= 270 || l >= 720 || k <=50 || k >= 500)
		            	break label0;
	            
		            detenerJuego = false;
		            
		            if(compruebaGanador()!= 0)
		            {
		            	detenerJuego = true;
		            }
		            
		            if(tablero.jugadores[turno-1].esPC)
		            {
		            	mover_pc();
		            	
		            	if(detenerJuego)//Implica que se ha terminado la partida
		            	{
		            		muestraGanador();
		            	}
	                       	
		            }
		            
	///// MIRAR TODO ESTO LOS BUCLES Y TAL Y TAL ////////////////////////////////////
		            // No es PC, es jugador normal.
		            else
		            {
			            //Calcula la coordenada i,j del tablero (16x16) que se pincha
			            //int i = Math.round((l-20) / 80);
		            	//int i = Math.round((l-200) / 80);
				           // int j = Math.round((k-50) / 80);
				            int i = 8, j = 8;
				            if (l>=270 && l<=340)
				            {
				            	if (k>=50 && k<=120)
				            	{
				            		i = 0; 
				            		j = 0;
				            	}
				            	else if (k>=145 && k<=215)
				            	{
				            		i = 0;
				            		j = 1;
				            	}
				            	else if (k>=240 && k<=310)
				            	{
				            		i = 0;
				            		j = 2;
				            	}
				            	else if (k>=335 && k<=405)
				            	{
				            		i = 0;
				            		j = 3;
				            	}
				            	else if (k>=430 && k<=500)
				            	{
				            		i = 0;
				            		j = 4;
				            	}
				            }
				            else if (l>=365 && l<=435)
				            {
				            	if (k>=50 && k<=120)
				            	{
				            		i = 1; 
				            		j = 0;
				            	}
				            	else if (k>=145 && k<=215)
				            	{
				            		i = 1;
				            		j = 1;
				            	}
				            	else if (k>=240 && k<=310)
				            	{
				            		i = 1;
				            		j = 2;
				            	}
				            	else if (k>=335 && k<=405)
				            	{
				            		i = 1;
				            		j = 3;
				            	}
				            	else if (k>=430 && k<=500)
				            	{
				            		i = 1;
				            		j = 4;
				            	}
				            }
				            else if (l>=460 && l<=530)
				            {
				            	if (k>=50 && k<=120)
				            	{
				            		i = 2; 
				            		j = 0;
				            	}
				            	else if (k>=145 && k<=215)
				            	{
				            		i = 2;
				            		j = 1;
				            	}
				            	else if (k>=240 && k<=310)
				            	{
				            		i = 2;
				            		j = 2;
				            	}
				            	else if (k>=335 && k<=405)
				            	{
				            		i = 2;
				            		j = 3;
				            	}
				            	else if (k>=430 && k<=500)
				            	{
				            		i = 2;
				            		j = 4;
				            	}
				            }
				            else if (l>=555 && l<=625)
				            {
				            	if (k>=50 && k<=120)
				            	{
				            		i = 3; 
				            		j = 0;
				            	}
				            	else if (k>=145 && k<=215)
				            	{
				            		i = 3;
				            		j = 1;
				            	}
				            	else if (k>=240 && k<=310)
				            	{
				            		i = 3;
				            		j = 2;
				            	}
				            	else if (k>=335 && k<=405)
				            	{
				            		i = 3;
				            		j = 3;
				            	}
				            	else if (k>=430 && k<=500)
				            	{
				            		i = 3;
				            		j = 4;
				            	}
				            }
				            else if (l>=650 && l<=720)
				            {
				            	if (k>=50 && k<=120)
				            	{
				            		i = 4; 
				            		j = 0;
				            	}
				            	else if (k>=145 && k<=215)
				            	{
				            		i = 4;
				            		j = 1;
				            	}
				            	else if (k>=240 && k<=310)
				            	{
				            		i = 4;
				            		j = 2;
				            	}
				            	else if (k>=335 && k<=405)
				            	{
				            		i = 4;
				            		j = 3;
				            	}
				            	else if (k>=430 && k<=500)
				            	{
				            		i = 4;
				            		j = 4;
				            	}
				            }
			          //Si deseleccionamos la casilla seleccionada
			            if(seleccionada_posi == i && seleccionada_posj == j)
			            {
			                if(flagSalto)
			                {
			                	for (int a=15; a>0; a--)
			                	{
			                		if (saltos[a] != -1)
			                		{
			                			borrarCuadro(saltos[a]%5, saltos[a]/5);
			                		}
			                	}
			                }
	            	
			            	borrarCuadro(i, j);
			                borrarCuadro (candidata_posi, candidata_posj);
			                pintarPieza(tablero.casillas[asociaCasilla(i,j)].numjugador, j, i, true);
			              
			                seleccionada_posj = -1;
			                seleccionada_posi = -1;	
			                candidata_posi = -1;
			                candidata_posj = -1;
			                
			                inicializaSaltos();
			                
			                saltos[0]= -1;
			                sal_borra[0] = -1;
			                vector_aux[0]=-1;
			                
			                break label0;
			            }            
	            
			            //Cuando seleccionamos
			            if(seleccionada_posi == -1 && seleccionada_posj == -1)
			            {	
			            	if (i>4 && j >4)
			            	{
			            		break label0;
			            	}
			            	//Si pinchamos en una casilla sin ficha (sin que haya nada seleccionado)
			            	if (tablero.casillas[asociaCasilla(i,j)].ocupado == false)
			                    break label0;
		            	
			            	//Si pinchamos para seleccionar en una ficha cuyo turno no corresponde
			            	if(tablero.casillas[asociaCasilla(i,j)].numjugador != turno)
			            		break label0;
		            	
			                seleccionada_posi = i;
			                seleccionada_posj = j;
		                               
		                
			                //Para comenzar el tiempo la primera vez que pinchemos
			                if(cuentaEmpezar==0)
			                {	
			                	cuentaEmpezar = 1;
			                	tiempo.start();
			                }
			              
			                dibujaSeleccion(i, j);
			                
			                saltos[0] = asociaCasilla(seleccionada_posi, seleccionada_posj); 
			                //System.out.println("buaahh " + saltos[0]);
				            System.out.println("sel " + seleccionada_posi + "-" + seleccionada_posj);

			            }
			            else //Caso en el que haya una ficha seleccionada y pincha en otra casilla 
			            {
			            	if (i>7 && j >7)
			            	{
			            		if(flagSalto)
				                {
				                	for (int a=15; a>0; a--)
				                	{
				                		if (saltos[a] != -1)
				                		{
				                			borrarCuadro(saltos[a]%7, saltos[a]/7);
				                		}
				                	}
				                }
		            	
				            	borrarCuadro(i, j);
				                borrarCuadro (candidata_posi, candidata_posj);
				                borrarCuadro (i, j);
				                pintarPieza(tablero.casillas[XasociaCasilla(seleccionada_posi,seleccionada_posj)].numjugador, seleccionada_posj, seleccionada_posi, true);
				                seleccionada_posj = -1;
				                seleccionada_posi = -1;	
				                inicializaSaltos();
				                saltos[0]= -1;
				                sal_borra[0] = -1;
				                vector_aux[0]=-1;
			            		break label0;
			            	}
			            	if(seleccionada_posi != i || seleccionada_posj != j)
			            	{     
					            System.out.println("sel_dentro " + seleccionada_posi + "-" + seleccionada_posj);

			             	 	if(tablero.casillas[asociaCasilla(i,j)].ocupado == false)
			             	 	{ 
			             	 		System.out.println("activa cuando ");
	//Se activa cuando hay posibilidad de movimiento (espera un nuevo click a esa posicion para ejecutar el cambio)
	             	 	            flag = false;
			             	 	    numCasillaCandidata = asociaCasilla(i, j);
			         	 			numCasillaSeleccionada = asociaCasilla(seleccionada_posi, seleccionada_posj);
			         	 			if (saltos[0] == -1)
			         	 			{
			         	 				saltos[0] = numCasillaSeleccionada; //La casilla seleccionada de verdad
			         	 				System.out.println("la casilla d verdad " + saltos[0]);
			         	 			}
			         	 			System.out.println("casSel: " + numCasillaSeleccionada);
			         	 			if(tablero.casillas[numCasillaSeleccionada].numjugador == 1)
			         	 			{
			         	 				System.out.println("pertenece al 1 y candi = " + numCasillaCandidata);
			         	 				//Tratamos el movimiento simple (para el jugador 1 y para el jugador 3)
			         	 				
			         	 			////////////////////////////////////////////////
			         	 				//MIOOOOOOOOOOOOOOOOO
			         	 				// Si solo andan para adelante, se quitaaaaaaaaaaaa
			         	 				//////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
			         	 				
			         	 				if (Cinco_restri.adyacentes[numCasillaSeleccionada][0] == numCasillaCandidata)
			         	 				{
			         	 					for (int a=15; a>0; a--)
			         	 					{
			         	 						if (saltos[a] != -1)
			         	 						{
			         	 							borrarCuadro(saltos[a]%5, saltos[a]/5);
			         	 						}
			         	 					}
			         	 					System.out.println(0);
			                 	 			flag = true;
			                 	 			flagSalto = false;
			                 	 			inicializaSaltos();
			         	 				}
			         	 				else
			         	 					if (Cinco_restri.adyacentes[numCasillaSeleccionada][1] == numCasillaCandidata)
				         	 				{
				         	 					for (int a=15; a>0; a--)
				         	 					{
				         	 						if (saltos[a] != -1)
				         	 						{
				         	 							borrarCuadro(saltos[a]%5, saltos[a]/5);
				         	 						}
				         	 					}
				         	 					System.out.println(1);
				                 	 			flag = true;
				                 	 			flagSalto = false;
				                 	 			inicializaSaltos();
				         	 				}
			         	 					else
			         	 						if (Cinco_restri.adyacentes[numCasillaSeleccionada][2] == numCasillaCandidata)
					         	 				{
					         	 					for (int a=15; a>0; a--)
					         	 					{
					         	 						if (saltos[a] != -1)
					         	 						{
					         	 							borrarCuadro(saltos[a]%5, saltos[a]/5);
					         	 						}
					         	 					}
					         	 					System.out.println(2);
					                 	 			flag = true;
					                 	 			flagSalto = false;
					                 	 			inicializaSaltos();
					         	 				}
			         	 						else
			         	 				
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
			         	 				
			         	 				
			         	 				
			         	 				if (Cinco_restri.adyacentes[numCasillaSeleccionada][3] == numCasillaCandidata)
			         	 				{
			         	 					for (int a=15; a>0; a--)
			         	 					{
			         	 						if (saltos[a] != -1)
			         	 						{
			         	 							borrarCuadro(saltos[a]%5, saltos[a]/5);
			         	 						}
			         	 					}
			         	 					System.out.println(3);
			                 	 			flag = true;
			                 	 			flagSalto = false;
			                 	 			inicializaSaltos();
			         	 				}
			         	 				
			         	 				else 
			         	 					if (Cinco_restri.adyacentes[numCasillaSeleccionada][4] == numCasillaCandidata)
			         	 					{
			         	 						for (int a=15; a>0; a--)
			         	 						{
			         	 							if (saltos[a] != -1)
			         	 							{
			         	 								borrarCuadro(saltos[a]%5, saltos[a]/5);
			         	 							}
			         	 						}
			         	 						System.out.println(4);
			         	 						flag = true;
			         	 						flagSalto = false;
			         	 						inicializaSaltos();
			         	 					}
			         	 					else 
			         	 						if (Cinco_restri.adyacentes[numCasillaSeleccionada][5] == numCasillaCandidata)
			         	 						{
			         	 							for (int a=15; a>0; a--)
			         	 							{
			         	 								if (saltos[a] != -1)
			         	 								{
			         	 									borrarCuadro(saltos[a]%5, saltos[a]/5);
			         	 								}
			         	 							}
			         	 							System.out.println(5);
			         	 							flag = true;
			         	 							flagSalto = false;
			         	 							inicializaSaltos();
			         	 						}
			         	 						else 
			         	 							if (Cinco_restri.adyacentes[numCasillaSeleccionada][6] == numCasillaCandidata)
			         	 							{
			         	 								for (int a=15; a>0; a--)
			         	 								{
			         	 									if (saltos[a] != -1)
			         	 									{
			         	 										borrarCuadro(saltos[a]%5, saltos[a]/5);
			         	 									}
			         	 								}
			         	 								System.out.println(6);
			         	 								flag = true;
			         	 								flagSalto = false;
			         	 								inicializaSaltos();
			         	 							}
			         	 							else 
			         	 								if (Cinco_restri.adyacentes[numCasillaSeleccionada][7] == numCasillaCandidata)
			         	 								{
			         	 									for (int a=15; a>0; a--)
			         	 									{
			         	 										if (saltos[a] != -1)
			         	 										{
			         	 											borrarCuadro(saltos[a]%5, saltos[a]/5);
			         	 										}
			         	 									}
			         	 									System.out.println(7);
			         	 									flag = true;
			         	 									flagSalto = false;
			         	 									inicializaSaltos();
			         	 								}
			         	 				
			         	 				System.out.println("fin");
	             	 			
			         	 			}
	          	 		
			         	 			else 
			         	 				if(tablero.casillas[numCasillaSeleccionada].numjugador == 2)
			         	 				{
	             	 			//Tratamos el movimiento simple (para el jugador 2 y para el jugador 4)
	             	 			
			         	 					if (Cinco_restri.adyacentes[numCasillaSeleccionada][0] == numCasillaCandidata)
			         	 					{
			         	 						for (int a=15; a>0; a--)
			         	 						{
			         	 							if (saltos[a] != -1)
			         	 							{
			         	 								borrarCuadro(saltos[a]%5, saltos[a]/5);
			         	 							}
			         	 						}
			         	 						flag = true;
			         	 						flagSalto = false;
			         	 						inicializaSaltos();
			         	 					}
			         	 					else 
			         	 						if (Cinco_restri.adyacentes[numCasillaSeleccionada][1] == numCasillaCandidata)
			         	 						{
			         	 							for (int a=15; a>0; a--)
			         	 							{
			         	 								if (saltos[a] != -1)
			         	 								{
			         	 									borrarCuadro(saltos[a]%5, saltos[a]/5);
			         	 								}
			         	 							}
			         	 							flag = true;
			         	 							flagSalto = false;
			         	 							inicializaSaltos();
			         	 						}
			         	 						else 
			         	 							if (Cinco_restri.adyacentes[numCasillaSeleccionada][2] == numCasillaCandidata)
			         	 							{
			         	 								for (int a=15; a>0; a--)
			         	 								{
			         	 									if (saltos[a] != -1)
			         	 									{
			         	 										borrarCuadro(saltos[a]%5, saltos[a]/5);
			         	 									}
			         	 								}
			         	 								flag = true;
			         	 								flagSalto = false;
			         	 								inicializaSaltos();
			         	 							}
			         	 							else 
			         	 								if (Cinco_restri.adyacentes[numCasillaSeleccionada][3] == numCasillaCandidata)
			         	 								{
			         	 									for (int a=15; a>0; a--)
			         	 									{
			         	 										if (saltos[a] != -1)
			         	 										{
			         	 											borrarCuadro(saltos[a]%5, saltos[a]/5);
			         	 										}
			         	 									}
			         	 									flag = true;
			         	 									flagSalto = false;
			         	 									inicializaSaltos();
			         	 								}
			         	 								else 
			         	 									if (Cinco_restri.adyacentes[numCasillaSeleccionada][4] == numCasillaCandidata)
			         	 									{
			         	 										for (int a=15; a>0; a--)
			         	 										{
			         	 											if (saltos[a] != -1)
			         	 											{
			         	 												borrarCuadro(saltos[a]%5, saltos[a]/5);
			         	 											}
			         	 										}
			         	 										flag = true;
			         	 										flagSalto = false;
			         	 										inicializaSaltos();
			         	 									}
			         	 					
			         	 ////////////////////////////////////////////////////////////////////////////////
			         	 					//MIOOOOOOOOOOOOOOOOOOOOOOOO
			         	 ////////////////////////////////////////////////////////////////////////////////					
	             	 			
			         	 									else 
				         	 									if (Cinco_restri.adyacentes[numCasillaSeleccionada][5] == numCasillaCandidata)
				         	 									{
				         	 										for (int a=15; a>0; a--)
				         	 										{
				         	 											if (saltos[a] != -1)
				         	 											{
				         	 												borrarCuadro(saltos[a]%5, saltos[a]/5);
				         	 											}
				         	 										}
				         	 										flag = true;
				         	 										flagSalto = false;
				         	 										inicializaSaltos();
				         	 									}
				         	 									else 
					         	 									if (Cinco_restri.adyacentes[numCasillaSeleccionada][6] == numCasillaCandidata)
					         	 									{
					         	 										for (int a=15; a>0; a--)
					         	 										{
					         	 											if (saltos[a] != -1)
					         	 											{
					         	 												borrarCuadro(saltos[a]%5, saltos[a]/5);
					         	 											}
					         	 										}
					         	 										flag = true;
					         	 										flagSalto = false;
					         	 										inicializaSaltos();
					         	 									}
					         	 									else 
						         	 									if (Cinco_restri.adyacentes[numCasillaSeleccionada][7] == numCasillaCandidata)
						         	 									{
						         	 										for (int a=15; a>0; a--)
						         	 										{
						         	 											if (saltos[a] != -1)
						         	 											{
						         	 												borrarCuadro(saltos[a]%5, saltos[a]/5);
						         	 											}
						         	 										}
						         	 										flag = true;
						         	 										flagSalto = false;
						         	 										inicializaSaltos();
						         	 									}
			         	 	////////////////////////////////////////////////////////////////////////////////////////////////////////////				
			         	 					
			         	 					//Tratamos la situacion de un salto (para el jugador 2 y para el jugador 4)
	             	 			
			         	 				if (Cinco_restri.adyacentes[saltos[0]][0] != -1 &&
			         	 						tablero.casillas[asociaCasilla(Cinco_restri.adyacentes[saltos[0]][0]%5,Cinco_restri.adyacentes[saltos[0]][0]/5)].ocupado == true &&
			         	 						Cinco_restri.adyacentes[Cinco_restri.adyacentes[saltos[0]][0]][0] == numCasillaCandidata)
			         	 				{
			         	 					sal_borra[numsalto] = asociaCasilla(Cinco_restri.adyacentes[saltos[numsalto]][0]%5,Cinco_restri.adyacentes[saltos[numsalto]][0]/5);
			         	 					flag = true;
			         	 					if (Cinco_restri.adyacentes[saltos[0]][0] != -1 &&
			         	 						tablero.casillas[asociaCasilla(Cinco_restri.adyacentes[saltos[0]][0]%5,Cinco_restri.adyacentes[saltos[0]][0]/5)].ocupado == true &&
			         	 						Cinco_restri.adyacentes[Cinco_restri.adyacentes[saltos[0]][0]][0] == numCasillaCandidata)
			         	 					{
			         	 						for (int a=15; a>0; a--)
			         	 						{
			         	 							if (saltos[a] != -1)
			         	 							{
			         	 								borrarCuadro(saltos[a]%5, saltos[a]/5);
			         	 							}
			         	 						}
			         	 						inicializaSaltos();
			         	 					}
			         	 					else
			         	 						if (flagSalto == false)
			         	 						{
			         	 							inicializaSaltos();
			         	 						}
			         	 						flagSalto = true;
			         	 						numsalto++; //Aumentamos en uno el numero de salto
			         	 						saltos[numsalto] = numCasillaCandidata;
			         	 				}
			         	 				else 
			         	 					if (Cinco_restri.adyacentes[saltos[0]][1] != -1 &&
			         	 							tablero.casillas[asociaCasilla(Cinco_restri.adyacentes[saltos[0]][1]%5,Cinco_restri.adyacentes[saltos[0]][1]/5)].ocupado == true &&
			         	 							Cinco_restri.adyacentes[Cinco_restri.adyacentes[saltos[0]][1]][1] == numCasillaCandidata)
			         	 					{
			         	 						sal_borra[numsalto] = asociaCasilla(Cinco_restri.adyacentes[saltos[numsalto]][1]%5,Cinco_restri.adyacentes[saltos[numsalto]][1]/5);
			         	 						flag = true;
			         	 						if (Cinco_restri.adyacentes[saltos[0]][1] != -1 &&
			         	 								tablero.casillas[asociaCasilla(Cinco_restri.adyacentes[saltos[0]][1]%5,Cinco_restri.adyacentes[saltos[0]][1]/5)].ocupado == true &&
			         	 								Cinco_restri.adyacentes[Cinco_restri.adyacentes[saltos[0]][1]][1] == numCasillaCandidata)
			         	 						{
			         	 							for (int a=15; a>0; a--)
			         	 							{
			         	 								if (saltos[a] != -1)
			         	 								{
			         	 									borrarCuadro(saltos[a]%5, saltos[a]/5);
			         	 								}
			         	 							}
			         	 							inicializaSaltos();
			         	 						}
			         	 						else 
			         	 							if (flagSalto == false)
			         	 							{
			         	 								inicializaSaltos();
			         	 							}
			         	 							flagSalto = true;
			         	 							numsalto++; //Aumentamos en uno el numero de salto
			         	 							saltos[numsalto] = numCasillaCandidata;
			         	 					}
			         	 					else 
			         	 						if (Cinco_restri.adyacentes[saltos[0]][2] != -1 &&
			         	 								tablero.casillas[asociaCasilla(Cinco_restri.adyacentes[saltos[0]][2]%5,Cinco_restri.adyacentes[saltos[0]][2]/5)].ocupado == true &&
			         	 								Cinco_restri.adyacentes[Cinco_restri.adyacentes[saltos[0]][2]][2] == numCasillaCandidata)
			         	 						{
			         	 							sal_borra[numsalto] = asociaCasilla(Cinco_restri.adyacentes[saltos[numsalto]][2]%5,Cinco_restri.adyacentes[saltos[numsalto]][2]/5);
			         	 							flag = true;
			         	 							if (Cinco_restri.adyacentes[saltos[0]][2] != -1 &&
			         	 									tablero.casillas[asociaCasilla(Cinco_restri.adyacentes[saltos[0]][2]%5,Cinco_restri.adyacentes[saltos[0]][2]/5)].ocupado == true &&
			         	 									Cinco_restri.adyacentes[Cinco_restri.adyacentes[saltos[0]][2]][2] == numCasillaCandidata)
			         	 							{
			         	 								for (int a=15; a>0; a--)
			         	 								{
			         	 									if (saltos[a] != -1)
			         	 									{
			         	 										borrarCuadro(saltos[a]%5, saltos[a]/5);
			         	 									}
			         	 								}
			         	 								inicializaSaltos();
			         	 							}
			         	 							else 
			         	 								if (flagSalto == false)
			         	 								{
			         	 									inicializaSaltos();
			         	 								}
			         	 								flagSalto = true;
			         	 								numsalto++; //Aumentamos en uno el numero de salto
			         	 								saltos[numsalto] = numCasillaCandidata;
			         	 						}
			         	 						else 
			         	 							if (Cinco_restri.adyacentes[saltos[0]][3] != -1 &&
			         	 									tablero.casillas[asociaCasilla(Cinco_restri.adyacentes[saltos[0]][3]%5,Cinco_restri.adyacentes[saltos[0]][3]/5)].ocupado == true &&
			         	 									Cinco_restri.adyacentes[Cinco_restri.adyacentes[saltos[0]][3]][3] == numCasillaCandidata)
			         	 							{
			         	 								System.out.println("Saltos 0 vale " + saltos[0]);
			         	 								System.out.println("Saltos numsalto vale " + saltos[numsalto]);
			         	 								System.out.println("el %16 vale " + Cinco_restri.adyacentes[saltos[numsalto]][3]%5 + " y el /16 vale " + Cinco_restri.adyacentes[saltos[numsalto]][3]/5);
			         	 								
			         	 								sal_borra[numsalto] = asociaCasilla(Cinco_restri.adyacentes[saltos[numsalto]][3]%5,Cinco_restri.adyacentes[saltos[numsalto]][3]/5);
			         	 								System.out.println("El valor de sal_borra[0] es " + sal_borra[0]);
			         	 								System.out.println("num salto vale " + numsalto);
			         	 								flag = true;
			         	 								if (Cinco_restri.adyacentes[saltos[0]][3] != -1 &&
			         	 										tablero.casillas[asociaCasilla(Cinco_restri.adyacentes[saltos[0]][3]%5,Cinco_restri.adyacentes[saltos[0]][3]/5)].ocupado == true &&
			         	 										Cinco_restri.adyacentes[Cinco_restri.adyacentes[saltos[0]][3]][3] == numCasillaCandidata)
			         	 								{
			         	 									for (int a=15; a>0; a--)
			         	 									{
			         	 										if (saltos[a] != -1)
			         	 										{
			         	 											borrarCuadro(saltos[a]%5, saltos[a]/5);
			         	 										}
			         	 			        				}
			         	 									inicializaSaltos();
			         	 								}
			         	 								else 
			         	 									if (flagSalto == false)
			         	 									{
			         	 										inicializaSaltos();
			         	 									}
			         	 									flagSalto = true;
			         	 									numsalto++; //Aumentamos en uno el numero de salto
			         	 									saltos[numsalto] = numCasillaCandidata;
			         	 							}
			         	 							else
			         	 								if (Cinco_restri.adyacentes[saltos[0]][4] != -1 &&
			         	 										tablero.casillas[asociaCasilla(Cinco_restri.adyacentes[saltos[0]][4]%5,Cinco_restri.adyacentes[saltos[0]][4]/5)].ocupado == true &&
			         	 										Cinco_restri.adyacentes[Cinco_restri.adyacentes[saltos[0]][4]][4] == numCasillaCandidata)
			         	 								{
			         	 									sal_borra[numsalto] = asociaCasilla(Cinco_restri.adyacentes[saltos[numsalto]][4]%5,Cinco_restri.adyacentes[saltos[numsalto]][4]/5);
			         	 									flag = true;
			         	 									if (Cinco_restri.adyacentes[saltos[0]][4] != -1 &&
			         	 											tablero.casillas[asociaCasilla(Cinco_restri.adyacentes[saltos[0]][4]%5,Cinco_restri.adyacentes[saltos[0]][4]/5)].ocupado == true &&
			         	 											Cinco_restri.adyacentes[Cinco_restri.adyacentes[saltos[0]][4]][4] == numCasillaCandidata)
			         	 									{
			         	 										for (int a=15; a>0; a--)
			         	 										{
			         	 											if (saltos[a] != -1)
			         	 											{
			         	 												borrarCuadro(saltos[a]%5, saltos[a]/5);
			         	 											}
			         	 										}
			         	 										inicializaSaltos();
			         	 									}
			         	 									else 
			         	 										if (flagSalto == false)
			         	 										{
			         	 											inicializaSaltos();
			         	 										}
			         	 										flagSalto = true;
			         	 										numsalto++; //Aumentamos en uno el numero de salto
			         	 										saltos[numsalto] = numCasillaCandidata;
			         	 								}
			         	 				
			       ////////////////////////////////////////////////////////////////////////////
			         	 				//MIO
			       /////////////////////////////////////////////////////////////////////////////
			         	 				
			         	 								else
				         	 								if (Cinco_restri.adyacentes[saltos[0]][5] != -1 &&
				         	 										tablero.casillas[asociaCasilla(Cinco_restri.adyacentes[saltos[0]][5]%5,Cinco_restri.adyacentes[saltos[0]][5]/5)].ocupado == true &&
				         	 										Cinco_restri.adyacentes[Cinco_restri.adyacentes[saltos[0]][5]][5] == numCasillaCandidata)
				         	 								{
				         	 									sal_borra[numsalto] = asociaCasilla(Cinco_restri.adyacentes[saltos[numsalto]][5]%5,Cinco_restri.adyacentes[saltos[numsalto]][5]/5);
				         	 									flag = true;
				         	 									if (Cinco_restri.adyacentes[saltos[0]][5] != -1 &&
				         	 											tablero.casillas[asociaCasilla(Cinco_restri.adyacentes[saltos[0]][5]%5,Cinco_restri.adyacentes[saltos[0]][5]/5)].ocupado == true &&
				         	 											Cinco_restri.adyacentes[Cinco_restri.adyacentes[saltos[0]][5]][5] == numCasillaCandidata)
				         	 									{
				         	 										for (int a=15; a>0; a--)
				         	 										{
				         	 											if (saltos[a] != -1)
				         	 											{
				         	 												borrarCuadro(saltos[a]%5, saltos[a]/5);
				         	 											}
				         	 										}
				         	 										inicializaSaltos();
				         	 									}
				         	 									else 
				         	 										if (flagSalto == false)
				         	 										{
				         	 											inicializaSaltos();
				         	 										}
				         	 										flagSalto = true;
				         	 										numsalto++; //Aumentamos en uno el numero de salto
				         	 										saltos[numsalto] = numCasillaCandidata;
				         	 								}
			         	 				
				         	 								else
					         	 								if (Cinco_restri.adyacentes[saltos[0]][6] != -1 &&
					         	 										tablero.casillas[asociaCasilla(Cinco_restri.adyacentes[saltos[0]][6]%5,Cinco_restri.adyacentes[saltos[0]][6]/5)].ocupado == true &&
					         	 										Cinco_restri.adyacentes[Cinco_restri.adyacentes[saltos[0]][6]][6] == numCasillaCandidata)
					         	 								{
					         	 									sal_borra[numsalto] = asociaCasilla(Cinco_restri.adyacentes[saltos[numsalto]][6]%5,Cinco_restri.adyacentes[saltos[numsalto]][6]/5);
					         	 									flag = true;
					         	 									if (Cinco_restri.adyacentes[saltos[0]][6] != -1 &&
					         	 											tablero.casillas[asociaCasilla(Cinco_restri.adyacentes[saltos[0]][6]%5,Cinco_restri.adyacentes[saltos[0]][6]/5)].ocupado == true &&
					         	 											Cinco_restri.adyacentes[Cinco_restri.adyacentes[saltos[0]][6]][6] == numCasillaCandidata)
					         	 									{
					         	 										for (int a=15; a>0; a--)
					         	 										{
					         	 											if (saltos[a] != -1)
					         	 											{
					         	 												borrarCuadro(saltos[a]%5, saltos[a]/5);
					         	 											}
					         	 										}
					         	 										inicializaSaltos();
					         	 									}
					         	 									else 
					         	 										if (flagSalto == false)
					         	 										{
					         	 											inicializaSaltos();
					         	 										}
					         	 										flagSalto = true;
					         	 										numsalto++; //Aumentamos en uno el numero de salto
					         	 										saltos[numsalto] = numCasillaCandidata;
					         	 								}
					         	 								else
						         	 								if (Cinco_restri.adyacentes[saltos[0]][7] != -1 &&
						         	 										tablero.casillas[asociaCasilla(Cinco_restri.adyacentes[saltos[0]][7]%5,Cinco_restri.adyacentes[saltos[0]][7]/5)].ocupado == true &&
						         	 										Cinco_restri.adyacentes[Cinco_restri.adyacentes[saltos[0]][7]][7] == numCasillaCandidata)
						         	 								{
						         	 									sal_borra[numsalto] = asociaCasilla(Cinco_restri.adyacentes[saltos[numsalto]][7]%5,Cinco_restri.adyacentes[saltos[numsalto]][7]/5);
						         	 									flag = true;
						         	 									if (Cinco_restri.adyacentes[saltos[0]][7] != -1 &&
						         	 											tablero.casillas[asociaCasilla(Cinco_restri.adyacentes[saltos[0]][7]%5,Cinco_restri.adyacentes[saltos[0]][7]/5)].ocupado == true &&
						         	 											Cinco_restri.adyacentes[Cinco_restri.adyacentes[saltos[0]][7]][7] == numCasillaCandidata)
						         	 									{
						         	 										for (int a=15; a>0; a--)
						         	 										{
						         	 											if (saltos[a] != -1)
						         	 											{
						         	 												borrarCuadro(saltos[a]%5, saltos[a]/5);
						         	 											}
						         	 										}
						         	 										inicializaSaltos();
						         	 									}
						         	 									else 
						         	 										if (flagSalto == false)
						         	 										{
						         	 											inicializaSaltos();
						         	 										}
						         	 										flagSalto = true;
						         	 										numsalto++; //Aumentamos en uno el numero de salto
						         	 										saltos[numsalto] = numCasillaCandidata;
						         	 								}
			         	 				
			         	 	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
			         	 				
	             	 			
			         	 				}
	                    
			         	 			if (flagSalto && flag)
			         	 			{
			         	 				if (numsalto == 1) //Para borrar las selecciones cuando se pivota con casillaSeleccionada
			         	 				{
			         	 					//System.out.println(numsalto);
			         	 					borrarCuadro (candidata_posi, candidata_posj);
			         	 				}
			         	 				candidata_posi = i;
			         	 				candidata_posj = j;
			         	 				dibujaCandidata(i,j);
			         	 				dibujaSeleccion(saltos[0]%5, saltos[0]/5);
			         	 				//System.out.println("salto???");
			         	 			}
	         	 			
			         	 			if(flag)
			         	 			{
	                			//Entramos aqui si ya esta seleccionada la posicion a la que
	                			//queremos mover y se esta esperando otro click ahi
	                			
	             	 			               			
	             	 		//hay ya una casilla seleccionada y la tenemos que quitar
			         	 				if (candidata_posi != -1 && candidata_posj != -1)
			         	 				{
			         	 					borrarCuadro (candidata_posi, candidata_posj);
			         	 					
			         	 				}
	                			
			         	 				candidata_posi = i;
			         	 				candidata_posj = j;
			         	 				dibujaCandidata(i,j);
			         	 				dibujaSeleccion(saltos[0]%5, saltos[0]/5);
			         	 				//System.out.println("JAVIsdfgsdf");
			         	 			}
			         	 			else
			         	 			{
			         	 				//Si el flag no esta activo no se hace nada (no hay seleccion ninguna)
			         	 			}
			             	 	}	
	             	 	
			            	}
	            }}
	    	}
	    	
		
	    	else  //caso en el que hacemos doble click
	    	{
	    		if(mouseevent.getClickCount()==2)
	    		{
	    			//System.out.println("JAVI");
	    			Graphics2D graphics2d = (Graphics2D)getGraphics();
	    			int l = mouseevent.getX();
	    			int k = mouseevent.getY();
	    			//if(l <= 20 || l >= 660 || k <=50 || k >= 690)
	    			//if(l <= 200 || l >= 800 || k <=50 || k >= 690)
	    			if(l <= 270 || l >= 720 || k <=50 || k >= 500)    
	    			{
	    				break label0;
	    			}
	            
	    			//int i = Math.round((l-20) / 80);
	    			//int i = Math.round((l-200) / 80);
			           // int j = Math.round((k-50) / 80);
			            int i = 0, j = 0;
			            if (l>=270 && l<=340)
			            {
			            	if (k>=50 && k<=120)
			            	{
			            		i = 0; 
			            		j = 0;
			            	}
			            	else if (k>=145 && k<=215)
			            	{
			            		i = 0;
			            		j = 1;
			            	}
			            	else if (k>=240 && k<=310)
			            	{
			            		i = 0;
			            		j = 2;
			            	}
			            	else if (k>=335 && k<=405)
			            	{
			            		i = 0;
			            		j = 3;
			            	}
			            	else if (k>=430 && k<=500)
			            	{
			            		i = 0;
			            		j = 4;
			            	}
			            }
			            else if (l>=365 && l<=435)
			            {
			            	if (k>=50 && k<=120)
			            	{
			            		i = 1; 
			            		j = 0;
			            	}
			            	else if (k>=145 && k<=215)
			            	{
			            		i = 1;
			            		j = 1;
			            	}
			            	else if (k>=240 && k<=310)
			            	{
			            		i = 1;
			            		j = 2;
			            	}
			            	else if (k>=335 && k<=405)
			            	{
			            		i = 1;
			            		j = 3;
			            	}
			            	else if (k>=430 && k<=500)
			            	{
			            		i = 1;
			            		j = 4;
			            	}
			            }
			            else if (l>=460 && l<=530)
			            {
			            	if (k>=50 && k<=120)
			            	{
			            		i = 2; 
			            		j = 0;
			            	}
			            	else if (k>=145 && k<=215)
			            	{
			            		i = 2;
			            		j = 1;
			            	}
			            	else if (k>=240 && k<=310)
			            	{
			            		i = 2;
			            		j = 2;
			            	}
			            	else if (k>=335 && k<=405)
			            	{
			            		i = 2;
			            		j = 3;
			            	}
			            	else if (k>=430 && k<=500)
			            	{
			            		i = 2;
			            		j = 4;
			            	}
			            }
			            else if (l>=555 && l<=625)
			            {
			            	if (k>=50 && k<=120)
			            	{
			            		i = 3; 
			            		j = 0;
			            	}
			            	else if (k>=145 && k<=215)
			            	{
			            		i = 3;
			            		j = 1;
			            	}
			            	else if (k>=240 && k<=310)
			            	{
			            		i = 3;
			            		j = 2;
			            	}
			            	else if (k>=335 && k<=405)
			            	{
			            		i = 3;
			            		j = 3;
			            	}
			            	else if (k>=430 && k<=500)
			            	{
			            		i = 3;
			            		j = 4;
			            	}
			            }
			            else if (l>=650 && l<=720)
			            {
			            	if (k>=50 && k<=120)
			            	{
			            		i = 4; 
			            		j = 0;
			            	}
			            	else if (k>=145 && k<=215)
			            	{
			            		i = 4;
			            		j = 1;
			            	}
			            	else if (k>=240 && k<=310)
			            	{
			            		i = 4;
			            		j = 2;
			            	}
			            	else if (k>=335 && k<=405)
			            	{
			            		i = 4;
			            		j = 3;
			            	}
			            	else if (k>=430 && k<=500)
			            	{
			            		i = 4;
			            		j = 4;
			            	}
			            }
	    			
	            //caso en el que no haya ninguna casilla seleccionada
	            if(seleccionada_posi == -1 && seleccionada_posj == -1)	
	            {
	            	break label0;
	            }
	            
	            //Habiendo una seleccionada, hacemos doble click en otra casilla
	    		if(seleccionada_posi != i || seleccionada_posj != j)
	            {
	    			borrarCuadro (candidata_posi, candidata_posj); // Para evitar que se quede una casilla candidata
	    							//dibujada cuando se hace un doble click incorrecto
	    			
	    			//actualizamos los indices de la casilla seleccionada
	    			candidata_posi = i;
	    			candidata_posj = j;
	    			System.out.println(flag);
	    			if(flag)//se puede realizar el movimiento
	              	{
	    				if(!flagSalto)
	    				{
	    					for (int a=0; a<16; a++)
	                        {
	                        	if (saltos[a] != -1)
	                        	{
	                        		borrarCuadro(saltos[a]%5, saltos[a]/5);
	                        	}
	                        }
	    				}
	    				
	    				numCasillaSeleccionada = asociaCasilla(seleccionada_posi, seleccionada_posj);
	    				numCasillaCandidata = asociaCasilla(candidata_posi, candidata_posj);
	    				dibujaCandidata(i,j);
	    				numsalto = 0;
	    				if(flagSalto)
	                    {
	    					
	                    	for (int a=1; a<16; a++)
	                    	{
	                    		if (saltos[a-1] != -1 && saltos[a] != -1)
	                    		{
	                    			borrarCuadro(saltos[a-1]%5, saltos[a-1]/5);
	                    			parpadeo();
	                    			borrarCuadro(sal_borra[a-1]%5, sal_borra[a-1]/5);
	                    			pintarPieza(tablero.casillas[numCasillaSeleccionada].numjugador, saltos[a]/5, saltos[a]%5, true);
	                    			//borrarCuadro(sal_borra[a-1]%5, sal_borra[a-1]/5);
	                    			numsalto++;
	                    			
	                    			parpadeo(); //Relentiza el proceso de dibujar los saltos
	                    			
	                    		}
	                    	}
	                    }
	                  
	    				borrarCuadro(seleccionada_posi, seleccionada_posj);
	    				
	    				//casilla_borrar = asociaCasilla(sal_borra[0]%5, sal_borra[0]/5);
	    				
	    				for (int a=0; a<16; a++)
	    				{
	    					//System.out.print(asociaCasilla(sal_borra[a]%5,sal_borra[a]/5) + ", ");
	    					if (sal_borra[a] != -1)
	    						vector_aux [a] = asociaCasilla(sal_borra[a]%5, sal_borra[a]/5);
	    				}
	    				/*
	    				for (int a=0; a<16; a++)
	    					if (sal_borra[a] != -1)
	    						borrarCuadro(sal_borra[a]%5, sal_borra[a]/5);
	                	*/
	    				pintarPieza(tablero.casillas[numCasillaSeleccionada].numjugador, candidata_posj, candidata_posi, true);
	    				
	
	///////////////////////////////////    				///////////////////////////////
	                    //mover(numCasillaSeleccionada, numCasillaCandidata, casilla_borrar);
	                    mover(numCasillaSeleccionada, numCasillaCandidata, vector_aux);
	                    for (int a = 0; a<16;a++){
	                    	vector_aux[a] = -1;
	                    	sal_borra[a] = -1;
	                    }
	     ////////////////////////////////////////////////                    /////////////////////////////
	                    if(compruebaGanador()!=0)
	                    {
	                    	detenerJuego = true;
	                    	muestraGanador();
	                    }
	                    
	                    seleccionada_posj = -1;
	                    seleccionada_posi = -1;	
	                    candidata_posi = -1;
	                    candidata_posj = -1;
	                    inicializaSaltos();
	                    saltos[0]= -1; //Desanclamos el numCasillaSeleccionada, ya se se mueve la ficha
	                    flagSalto =false;
	                    flag = false;
	                    numsalto = 0;
	                    if(tablero.jugadores[turno-1].esPC && !detenerJuego)
	            		{
	            			mover_pc();
	            		}
	                    
	                    break label0;
	              	}
	              	else //no se puede realizar el movimiento
	              	{
	              		lAviso.setText("¡ERROR! El movimiento es incorrecto, no se puede realizar");
	              		
	              		/////////////////////SONIDOOOOOOOOOOOOOOOOOOOOOOOOO
	              		//soni.playSound("Sonido/Error.wav");
	              		////////////////////////////////////////////////
	              	}          	  
	      
	    	  		}
	    		}
	   
	    	}
			}//fin tipotabl == 4
		 	if (tipotabl == 2)
			{
				if(tablero.jugadores[turno-1].esPC && cuentaEmpezar==0)
			 	{
			 		cuentaEmpezar = 1;
		        	tiempo.start();
			 	}	 	
	    	
	    	//caso en el que hacemos un solo click
			 	if(mouseevent.getClickCount() == 1)
		    	{    		
		    		Graphics2D graphics2d = (Graphics2D)getGraphics();
		            int l = mouseevent.getX();
		            int k = mouseevent.getY();
		            
		            //if(l <= 20 || l >= 660 || k <=50 || k >= 690)
		            //if(l <= 200 || l >= 800 || k <=50 || k >= 690)
		            if(l <= 200 + 84 || l >= 662 + 84|| k <=50 || k >= 512)
		            	break label0;
	            
		            detenerJuego = false;
		            
		            if(compruebaGanador()!= 0)
		            {
		            	detenerJuego = true;
		            }
		            
		            if(tablero.jugadores[turno-1].esPC)
		            {
		            	mover_pc();
		            	
		            	if(detenerJuego)//Implica que se ha terminado la partida
		            	{
		            		muestraGanador();
		            	}
	                       	
		            }
		            
	///// MIRAR TODO ESTO LOS BUCLES Y TAL Y TAL ////////////////////////////////////
		            // No es PC, es jugador normal.
		            else
		            {
			            //Calcula la coordenada i,j del tablero (16x16) que se pincha
			            //int i = Math.round((l-20) / 80);
		            	//int i = Math.round((l-200) / 60);
				           // int j = Math.round((k-50) / 60);
				            int i=8,j=8; 
				            if (l>=200 + 84 && l<=254 + 84)
				            {
				            	if (k>=50 && k<=104)
				            	{
				            		i = 0; 
				            		j = 0;
				            	}
				            	else if (k>=118 && k<=172)
				            	{
				            		i = 0;
				            		j = 1;
				            	}
				            	else if (k>=186 && k<=240)
				            	{
				            		i = 0;
				            		j = 2;
				            	}
				            	else if (k>=254 && k<=308)
				            	{
				            		i = 0;
				            		j = 3;
				            	}
				            	else if (k>=322 && k<=376)
				            	{
				            		i = 0;
				            		j = 4;
				            	}
				            	else if (k>=390 && k<=444)
				            	{
				            		i = 0;
				            		j = 5;
				            	}
				            	else if (k>=458 && k<=512)
				            	{
				            		i = 0;
				            		j = 6;
				            	}
				            }
				            else if (l>=268 + 84 && l<=322 + 84)
				            {
				            	if (k>=50 && k<=104)
				            	{
				            		i = 1; 
				            		j = 0;
				            	}
				            	else if (k>=118 && k<=172)
				            	{
				            		i = 1;
				            		j = 1;
				            	}
				            	else if (k>=186 && k<=240)
				            	{
				            		i = 1;
				            		j = 2;
				            	}
				            	else if (k>=254 && k<=308)
				            	{
				            		i = 1;
				            		j = 3;
				            	}
				            	else if (k>=322 && k<=376)
				            	{
				            		i = 1;
				            		j = 4;
				            	}
				            	else if (k>=390 && k<=444)
				            	{
				            		i = 1;
				            		j = 5;
				            	}
				            	else if (k>=458 && k<=512)
				            	{
				            		i = 1;
				            		j = 6;
				            	}
				            }
				            else if (l>=336 + 84 && l<=390 + 84)
				            {
				            	if (k>=50 && k<=104)
				            	{
				            		i = 2; 
				            		j = 0;
				            	}
				            	else if (k>=118 && k<=172)
				            	{
				            		i = 2;
				            		j = 1;
				            	}
				            	else if (k>=186 && k<=240)
				            	{
				            		i = 2;
				            		j = 2;
				            	}
				            	else if (k>=254 && k<=308)
				            	{
				            		i = 2;
				            		j = 3;
				            	}
				            	else if (k>=322 && k<=376)
				            	{
				            		i = 2;
				            		j = 4;
				            	}
				            	else if (k>=390 && k<=444)
				            	{
				            		i = 2;
				            		j = 5;
				            	}
				            	else if (k>=458 && k<=512)
				            	{
				            		i = 2;
				            		j = 6;
				            	}
				            }
				            else if (l>=404 + 84 && l<=458 + 84)
				            {
				            	if (k>=50 && k<=104)
				            	{
				            		i = 3; 
				            		j = 0;
				            	}
				            	else if (k>=118 && k<=172)
				            	{
				            		i = 3;
				            		j = 1;
				            	}
				            	else if (k>=186 && k<=240)
				            	{
				            		i = 3;
				            		j = 2;
				            	}
				            	else if (k>=254 && k<=308)
				            	{
				            		i = 3;
				            		j = 3;
				            	}
				            	else if (k>=322 && k<=376)
				            	{
				            		i = 3;
				            		j = 4;
				            	}
				            	else if (k>=390 && k<=444)
				            	{
				            		i = 3;
				            		j = 5;
				            	}
				            	else if (k>=458 && k<=512)
				            	{
				            		i = 3;
				            		j = 6;
				            	}
				            }
				            else if (l>=472 + 84 && l<=526 + 84)
				            {
				            	if (k>=50 && k<=104)
				            	{
				            		i = 4; 
				            		j = 0;
				            	}
				            	else if (k>=118 && k<=172)
				            	{
				            		i = 4;
				            		j = 1;
				            	}
				            	else if (k>=186 && k<=240)
				            	{
				            		i = 4;
				            		j = 2;
				            	}
				            	else if (k>=254 && k<=308)
				            	{
				            		i = 4;
				            		j = 3;
				            	}
				            	else if (k>=322 && k<=376)
				            	{
				            		i = 4;
				            		j = 4;
				            	}
				            	else if (k>=390 && k<=444)
				            	{
				            		i = 4;
				            		j = 5;
				            	}
				            	else if (k>=458 && k<=512)
				            	{
				            		i = 4;
				            		j = 6;
				            	}
				            }
				            else if (l>=540 + 84 && l<=594 + 84)
				            {
				            	if (k>=50 && k<=104)
				            	{
				            		i = 5; 
				            		j = 0;
				            	}
				            	else if (k>=118 && k<=172)
				            	{
				            		i = 5;
				            		j = 1;
				            	}
				            	else if (k>=186 && k<=240)
				            	{
				            		i = 5;
				            		j = 2;
				            	}
				            	else if (k>=254 && k<=308)
				            	{
				            		i = 5;
				            		j = 3;
				            	}
				            	else if (k>=322 && k<=376)
				            	{
				            		i = 5;
				            		j = 4;
				            	}
				            	else if (k>=390 && k<=444)
				            	{
				            		i = 5;
				            		j = 5;
				            	}
				            	else if (k>=458 && k<=512)
				            	{
				            		i = 5;
				            		j = 6;
				            	}
				            }
				            else if (l>=608 + 84 && l<=662 + 84)
				            {
				            	if (k>=50 && k<=104)
				            	{
				            		i = 6; 
				            		j = 0;
				            	}
				            	else if (k>=118 && k<=172)
				            	{
				            		i = 6;
				            		j = 1;
				            	}
				            	else if (k>=186 && k<=240)
				            	{
				            		i = 6;
				            		j = 2;
				            	}
				            	else if (k>=254 && k<=308)
				            	{
				            		i = 6;
				            		j = 3;
				            	}
				            	else if (k>=322 && k<=376)
				            	{
				            		i = 6;
				            		j = 4;
				            	}
				            	else if (k>=390 && k<=444)
				            	{
				            		i = 6;
				            		j = 5;
				            	}
				            	else if (k>=458 && k<=512)
				            	{
				            		i = 6;
				            		j = 6;
				            	}
				            } 
		                     
			          //Si deseleccionamos la casilla seleccionada
			            if(seleccionada_posi == i && seleccionada_posj == j)
			            {
			                if(flagSalto)
			                {
			                	for (int a=15; a>0; a--)
			                	{
			                		if (saltos[a] != -1)
			                		{
			                			borrarCuadro(saltos[a]%7, saltos[a]/7);
			                		}
			                	}
			                }
	            	
			            	borrarCuadro(i, j);
			                borrarCuadro (candidata_posi, candidata_posj);
			                pintarPieza(tablero.casillas[XasociaCasilla(i,j)].numjugador, j, i, true);
			              
			                seleccionada_posj = -1;
			                seleccionada_posi = -1;	
			                candidata_posi = -1;
			                candidata_posj = -1;
			                
			                inicializaSaltos();
			                
			                saltos[0]= -1;
			                sal_borra[0] = -1;
			                vector_aux[0]=-1;
			                
			                break label0;
			            }            
	            
			            //Cuando seleccionamos
			            if(seleccionada_posi == -1 && seleccionada_posj == -1)
			            {	
			            	if (i>7 && j >7)
			            	{
			            		break label0;
			            	}
			            	//Si pinchamos en una casilla sin ficha (sin que haya nada seleccionado)
			            	if (tablero.casillas[XasociaCasilla(i,j)].ocupado == false)
			                    break label0;
		            	
			            	//Si pinchamos para seleccionar en una ficha cuyo turno no corresponde
			            	if(tablero.casillas[XasociaCasilla(i,j)].numjugador != turno)
			            		break label0;
		            	
			                seleccionada_posi = i;
			                seleccionada_posj = j;
		                               
		                
			                //Para comenzar el tiempo la primera vez que pinchemos
			                if(cuentaEmpezar==0)
			                {	
			                	cuentaEmpezar = 1;
			                	tiempo.start();
			                }
			              
			                dibujaSeleccion(i, j);
			                
			                saltos[0] = XasociaCasilla(seleccionada_posi, seleccionada_posj); 
			                //System.out.println("buaahh " + saltos[0]);
			            }
			            
			            else //Caso en el que haya una ficha seleccionada y pincha en otra casilla 
			            {
			            	if (i>7 && j >7)
			            	{
			            		if(flagSalto)
				                {
				                	for (int a=15; a>0; a--)
				                	{
				                		if (saltos[a] != -1)
				                		{
				                			borrarCuadro(saltos[a]%7, saltos[a]/7);
				                		}
				                	}
				                }
		            	
				            	borrarCuadro(i, j);
				                borrarCuadro (candidata_posi, candidata_posj);
				                borrarCuadro (i, j);
				                pintarPieza(tablero.casillas[XasociaCasilla(seleccionada_posi,seleccionada_posj)].numjugador, seleccionada_posj, seleccionada_posi, true);
				                seleccionada_posj = -1;
				                seleccionada_posi = -1;	
				                inicializaSaltos();
				                saltos[0]= -1;
				                sal_borra[0] = -1;
				                vector_aux[0]=-1;
			            		break label0;
			            	}
			            	if(seleccionada_posi != i || seleccionada_posj != j)
			            	{            		
			             	 	if(tablero.casillas[XasociaCasilla(i,j)].ocupado == false)
			             	 	{ 
	//Se activa cuando hay posibilidad de movimiento (espera un nuevo click a esa posicion para ejecutar el cambio)
	             	 	            flag = false;
			             	 	    numCasillaCandidata = XasociaCasilla(i, j);
			         	 			numCasillaSeleccionada = XasociaCasilla(seleccionada_posi, seleccionada_posj);
			         	 			if (saltos[0] == -1)
			         	 			{
			         	 				saltos[0] = numCasillaSeleccionada; //La casilla seleccionada de verdad
			         	 				System.out.println("la casilla d verdad " + saltos[0]);
			         	 			}
	         	 			
			         	 			if(tablero.casillas[numCasillaSeleccionada].numjugador == 1)
			         	 			{
			         	 				//Tratamos el movimiento simple (para el jugador 1 y para el jugador 3)
			         	 				
			         	 			////////////////////////////////////////////////
			         	 				//MIOOOOOOOOOOOOOOOOO
			         	 			//////////////////////////////////////////////////
			         	 				if (SieteX.adyacentes[numCasillaSeleccionada][0] == numCasillaCandidata)
			         	 				{
			         	 					for (int a=15; a>0; a--)
			         	 					{
			         	 						if (saltos[a] != -1)
			         	 						{
			         	 							borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 						}
			         	 					}
			                 	 			flag = true;
			                 	 			flagSalto = false;
			                 	 			inicializaSaltos();
			         	 				}
			         	 				else
			         	 					if (SieteX.adyacentes[numCasillaSeleccionada][1] == numCasillaCandidata)
				         	 				{
				         	 					for (int a=15; a>0; a--)
				         	 					{
				         	 						if (saltos[a] != -1)
				         	 						{
				         	 							borrarCuadro(saltos[a]%7, saltos[a]/7);
				         	 						}
				         	 					}
				                 	 			flag = true;
				                 	 			flagSalto = false;
				                 	 			inicializaSaltos();
				         	 				}
			         	 					else
			         	 						if (SieteX.adyacentes[numCasillaSeleccionada][2] == numCasillaCandidata)
					         	 				{
					         	 					for (int a=15; a>0; a--)
					         	 					{
					         	 						if (saltos[a] != -1)
					         	 						{
					         	 							borrarCuadro(saltos[a]%7, saltos[a]/7);
					         	 						}
					         	 					}
					                 	 			flag = true;
					                 	 			flagSalto = false;
					                 	 			inicializaSaltos();
					         	 				}
			         	 						else
			         	 				
			   //////////////////////////////////////////////////////////////////////////////////////////////
			         	 				
			         	 				
			         	 				
			         	 				if (SieteX.adyacentes[numCasillaSeleccionada][3] == numCasillaCandidata)
			         	 				{
			         	 					for (int a=15; a>0; a--)
			         	 					{
			         	 						if (saltos[a] != -1)
			         	 						{
			         	 							borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 						}
			         	 					}
			                 	 			flag = true;
			                 	 			flagSalto = false;
			                 	 			inicializaSaltos();
			         	 				}
			         	 				
			         	 				else 
			         	 					if (SieteX.adyacentes[numCasillaSeleccionada][4] == numCasillaCandidata)
			         	 					{
			         	 						for (int a=15; a>0; a--)
			         	 						{
			         	 							if (saltos[a] != -1)
			         	 							{
			         	 								borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 							}
			         	 						}
			         	 						flag = true;
			         	 						flagSalto = false;
			         	 						inicializaSaltos();
			         	 					}
			         	 					else 
			         	 						if (SieteX.adyacentes[numCasillaSeleccionada][5] == numCasillaCandidata)
			         	 						{
			         	 							for (int a=15; a>0; a--)
			         	 							{
			         	 								if (saltos[a] != -1)
			         	 								{
			         	 									borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 								}
			         	 							}
			         	 							flag = true;
			         	 							flagSalto = false;
			         	 							inicializaSaltos();
			         	 						}
			         	 						else 
			         	 							if (SieteX.adyacentes[numCasillaSeleccionada][6] == numCasillaCandidata)
			         	 							{
			         	 								for (int a=15; a>0; a--)
			         	 								{
			         	 									if (saltos[a] != -1)
			         	 									{
			         	 										borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 									}
			         	 								}
			         	 								flag = true;
			         	 								flagSalto = false;
			         	 								inicializaSaltos();
			         	 							}
			         	 							else 
			         	 								if (SieteX.adyacentes[numCasillaSeleccionada][7] == numCasillaCandidata)
			         	 								{
			         	 									for (int a=15; a>0; a--)
			         	 									{
			         	 										if (saltos[a] != -1)
			         	 										{
			         	 											borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 										}
			         	 									}
			         	 									flag = true;
			         	 									flagSalto = false;
			         	 									inicializaSaltos();
			         	 								}
	             	 			
			         	 			}
	          	 		
			         	 			else 
			         	 				if(tablero.casillas[numCasillaSeleccionada].numjugador == 2)
			         	 						//|| tablero.casillas[numCasillaSeleccionada].numjugador == 4)
			         	 				{
	             	 			//Tratamos el movimiento simple (para el jugador 2 y para el jugador 4)
	             	 			
			         	 					if (SieteX.adyacentes[numCasillaSeleccionada][0] == numCasillaCandidata)
			         	 					{
			         	 						for (int a=15; a>0; a--)
			         	 						{
			         	 							if (saltos[a] != -1)
			         	 							{
			         	 								borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 							}
			         	 						}
			         	 						flag = true;
			         	 						flagSalto = false;
			         	 						inicializaSaltos();
			         	 					}
			         	 					else 
			         	 						if (SieteX.adyacentes[numCasillaSeleccionada][1] == numCasillaCandidata)
			         	 						{
			         	 							for (int a=15; a>0; a--)
			         	 							{
			         	 								if (saltos[a] != -1)
			         	 								{
			         	 									borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 								}
			         	 							}
			         	 							flag = true;
			         	 							flagSalto = false;
			         	 							inicializaSaltos();
			         	 						}
			         	 						else 
			         	 							if (SieteX.adyacentes[numCasillaSeleccionada][2] == numCasillaCandidata)
			         	 							{
			         	 								for (int a=15; a>0; a--)
			         	 								{
			         	 									if (saltos[a] != -1)
			         	 									{
			         	 										borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 									}
			         	 								}
			         	 								flag = true;
			         	 								flagSalto = false;
			         	 								inicializaSaltos();
			         	 							}
			         	 							else 
			         	 								if (SieteX.adyacentes[numCasillaSeleccionada][3] == numCasillaCandidata)
			         	 								{
			         	 									for (int a=15; a>0; a--)
			         	 									{
			         	 										if (saltos[a] != -1)
			         	 										{
			         	 											borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 										}
			         	 									}
			         	 									flag = true;
			         	 									flagSalto = false;
			         	 									inicializaSaltos();
			         	 								}
			         	 								else 
			         	 									if (SieteX.adyacentes[numCasillaSeleccionada][4] == numCasillaCandidata)
			         	 									{
			         	 										for (int a=15; a>0; a--)
			         	 										{
			         	 											if (saltos[a] != -1)
			         	 											{
			         	 												borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 											}
			         	 										}
			         	 										flag = true;
			         	 										flagSalto = false;
			         	 										inicializaSaltos();
			         	 									}
			         	 					
			         	 ////////////////////////////////////////////////////////////////////////////////
			         	 					//MIOOOOOOOOOOOOOOOOOOOOOOOO
			         	 ////////////////////////////////////////////////////////////////////////////////					
	             	 			
			         	 									else 
				         	 									if (SieteX.adyacentes[numCasillaSeleccionada][5] == numCasillaCandidata)
				         	 									{
				         	 										for (int a=15; a>0; a--)
				         	 										{
				         	 											if (saltos[a] != -1)
				         	 											{
				         	 												borrarCuadro(saltos[a]%7, saltos[a]/7);
				         	 											}
				         	 										}
				         	 										flag = true;
				         	 										flagSalto = false;
				         	 										inicializaSaltos();
				         	 									}
				         	 									else 
					         	 									if (SieteX.adyacentes[numCasillaSeleccionada][6] == numCasillaCandidata)
					         	 									{
					         	 										for (int a=15; a>0; a--)
					         	 										{
					         	 											if (saltos[a] != -1)
					         	 											{
					         	 												borrarCuadro(saltos[a]%7, saltos[a]/7);
					         	 											}
					         	 										}
					         	 										flag = true;
					         	 										flagSalto = false;
					         	 										inicializaSaltos();
					         	 									}
					         	 									else 
						         	 									if (SieteX.adyacentes[numCasillaSeleccionada][7] == numCasillaCandidata)
						         	 									{
						         	 										for (int a=15; a>0; a--)
						         	 										{
						         	 											if (saltos[a] != -1)
						         	 											{
						         	 												borrarCuadro(saltos[a]%7, saltos[a]/7);
						         	 											}
						         	 										}
						         	 										flag = true;
						         	 										flagSalto = false;
						         	 										inicializaSaltos();
						         	 									}
			         	 	////////////////////////////////////////////////////////////////////////////////////////////////////////////				
			         	 					
			         	 					//Tratamos la situacion de un salto (para el jugador 2 y para el jugador 4)
	             	 			
			         	 				if (SieteX.adyacentes[saltos[0]][0] != -1 &&
			         	 						tablero.casillas[XasociaCasilla(SieteX.adyacentes[saltos[0]][0]%7,SieteX.adyacentes[saltos[0]][0]/7)].ocupado == true &&
			         	 						SieteX.adyacentes[SieteX.adyacentes[saltos[0]][0]][0] == numCasillaCandidata)
			         	 				{
			         	 					sal_borra[numsalto] = XasociaCasilla(SieteX.adyacentes[saltos[numsalto]][0]%7,SieteX.adyacentes[saltos[numsalto]][0]/7);
			         	 					flag = true;
			         	 					if (SieteX.adyacentes[saltos[0]][0] != -1 &&
			         	 						tablero.casillas[XasociaCasilla(SieteX.adyacentes[saltos[0]][0]%7,SieteX.adyacentes[saltos[0]][0]/7)].ocupado == true &&
			         	 						SieteX.adyacentes[SieteX.adyacentes[saltos[0]][0]][0] == numCasillaCandidata)
			         	 					{
			         	 						for (int a=15; a>0; a--)
			         	 						{
			         	 							if (saltos[a] != -1)
			         	 							{
			         	 								borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 							}
			         	 						}
			         	 						inicializaSaltos();
			         	 					}
			         	 					else
			         	 						if (flagSalto == false)
			         	 						{
			         	 							inicializaSaltos();
			         	 						}
			         	 						flagSalto = true;
			         	 						numsalto++; //Aumentamos en uno el numero de salto
			         	 						saltos[numsalto] = numCasillaCandidata;
			         	 				}
			         	 				else 
			         	 					if (SieteX.adyacentes[saltos[0]][1] != -1 &&
			         	 							tablero.casillas[XasociaCasilla(SieteX.adyacentes[saltos[0]][1]%7,SieteX.adyacentes[saltos[0]][1]/7)].ocupado == true &&
			         	 							SieteX.adyacentes[SieteX.adyacentes[saltos[0]][1]][1] == numCasillaCandidata)
			         	 					{
			         	 						sal_borra[numsalto] = XasociaCasilla(SieteX.adyacentes[saltos[numsalto]][1]%7,SieteX.adyacentes[saltos[numsalto]][1]/7);
			         	 						flag = true;
			         	 						if (SieteX.adyacentes[saltos[0]][1] != -1 &&
			         	 								tablero.casillas[XasociaCasilla(SieteX.adyacentes[saltos[0]][1]%7,SieteX.adyacentes[saltos[0]][1]/7)].ocupado == true &&
			         	 								SieteX.adyacentes[SieteX.adyacentes[saltos[0]][1]][1] == numCasillaCandidata)
			         	 						{
			         	 							for (int a=15; a>0; a--)
			         	 							{
			         	 								if (saltos[a] != -1)
			         	 								{
			         	 									borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 								}
			         	 							}
			         	 							inicializaSaltos();
			         	 						}
			         	 						else 
			         	 							if (flagSalto == false)
			         	 							{
			         	 								inicializaSaltos();
			         	 							}
			         	 							flagSalto = true;
			         	 							numsalto++; //Aumentamos en uno el numero de salto
			         	 							saltos[numsalto] = numCasillaCandidata;
			         	 					}
			         	 					else 
			         	 						if (SieteX.adyacentes[saltos[0]][2] != -1 &&
			         	 								tablero.casillas[XasociaCasilla(SieteX.adyacentes[saltos[0]][2]%7,SieteX.adyacentes[saltos[0]][2]/7)].ocupado == true &&
			         	 								SieteX.adyacentes[SieteX.adyacentes[saltos[0]][2]][2] == numCasillaCandidata)
			         	 						{
			         	 							sal_borra[numsalto] = XasociaCasilla(SieteX.adyacentes[saltos[numsalto]][2]%7,SieteX.adyacentes[saltos[numsalto]][2]/7);
			         	 							flag = true;
			         	 							if (SieteX.adyacentes[saltos[0]][2] != -1 &&
			         	 									tablero.casillas[XasociaCasilla(SieteX.adyacentes[saltos[0]][2]%7,SieteX.adyacentes[saltos[0]][2]/7)].ocupado == true &&
			         	 									SieteX.adyacentes[SieteX.adyacentes[saltos[0]][2]][2] == numCasillaCandidata)
			         	 							{
			         	 								for (int a=15; a>0; a--)
			         	 								{
			         	 									if (saltos[a] != -1)
			         	 									{
			         	 										borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 									}
			         	 								}
			         	 								inicializaSaltos();
			         	 							}
			         	 							else 
			         	 								if (flagSalto == false)
			         	 								{
			         	 									inicializaSaltos();
			         	 								}
			         	 								flagSalto = true;
			         	 								numsalto++; //Aumentamos en uno el numero de salto
			         	 								saltos[numsalto] = numCasillaCandidata;
			         	 						}
			         	 						else 
			         	 							if (SieteX.adyacentes[saltos[0]][3] != -1 &&
			         	 									tablero.casillas[XasociaCasilla(SieteX.adyacentes[saltos[0]][3]%7,SieteX.adyacentes[saltos[0]][3]/7)].ocupado == true &&
			         	 									SieteX.adyacentes[SieteX.adyacentes[saltos[0]][3]][3] == numCasillaCandidata)
			         	 							{
			         	 								System.out.println("Saltos 0 vale " + saltos[0]);
			         	 								System.out.println("Saltos numsalto vale " + saltos[numsalto]);
			         	 								System.out.println("el %16 vale " + SieteX.adyacentes[saltos[numsalto]][3]%7 + " y el /16 vale " + SieteX.adyacentes[saltos[numsalto]][3]/7);
			         	 								
			         	 								sal_borra[numsalto] = XasociaCasilla(SieteX.adyacentes[saltos[numsalto]][3]%7,SieteX.adyacentes[saltos[numsalto]][3]/7);
			         	 								System.out.println("El valor de sal_borra[0] es " + sal_borra[0]);
			         	 								System.out.println("num salto vale " + numsalto);
			         	 								flag = true;
			         	 								if (SieteX.adyacentes[saltos[0]][3] != -1 &&
			         	 										tablero.casillas[XasociaCasilla(SieteX.adyacentes[saltos[0]][3]%7,SieteX.adyacentes[saltos[0]][3]/7)].ocupado == true &&
			         	 										SieteX.adyacentes[SieteX.adyacentes[saltos[0]][3]][3] == numCasillaCandidata)
			         	 								{
			         	 									for (int a=15; a>0; a--)
			         	 									{
			         	 										if (saltos[a] != -1)
			         	 										{
			         	 											borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 										}
			         	 			        				}
			         	 									inicializaSaltos();
			         	 								}
			         	 								else 
			         	 									if (flagSalto == false)
			         	 									{
			         	 										inicializaSaltos();
			         	 									}
			         	 									flagSalto = true;
			         	 									numsalto++; //Aumentamos en uno el numero de salto
			         	 									saltos[numsalto] = numCasillaCandidata;
			         	 							}
			         	 							else
			         	 								if (SieteX.adyacentes[saltos[0]][4] != -1 &&
			         	 										tablero.casillas[XasociaCasilla(SieteX.adyacentes[saltos[0]][4]%7,SieteX.adyacentes[saltos[0]][4]/7)].ocupado == true &&
			         	 										SieteX.adyacentes[SieteX.adyacentes[saltos[0]][4]][4] == numCasillaCandidata)
			         	 								{
			         	 									sal_borra[numsalto] = XasociaCasilla(SieteX.adyacentes[saltos[numsalto]][4]%7,SieteX.adyacentes[saltos[numsalto]][4]/7);
			         	 									flag = true;
			         	 									if (SieteX.adyacentes[saltos[0]][4] != -1 &&
			         	 											tablero.casillas[XasociaCasilla(SieteX.adyacentes[saltos[0]][4]%7,SieteX.adyacentes[saltos[0]][4]/7)].ocupado == true &&
			         	 											SieteX.adyacentes[SieteX.adyacentes[saltos[0]][4]][4] == numCasillaCandidata)
			         	 									{
			         	 										for (int a=15; a>0; a--)
			         	 										{
			         	 											if (saltos[a] != -1)
			         	 											{
			         	 												borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 											}
			         	 										}
			         	 										inicializaSaltos();
			         	 									}
			         	 									else 
			         	 										if (flagSalto == false)
			         	 										{
			         	 											inicializaSaltos();
			         	 										}
			         	 										flagSalto = true;
			         	 										numsalto++; //Aumentamos en uno el numero de salto
			         	 										saltos[numsalto] = numCasillaCandidata;
			         	 								}
			         	 				
			       ////////////////////////////////////////////////////////////////////////////
			         	 				//MIO
			       /////////////////////////////////////////////////////////////////////////////
			         	 				
			         	 								else
				         	 								if (SieteX.adyacentes[saltos[0]][5] != -1 &&
				         	 										tablero.casillas[XasociaCasilla(SieteX.adyacentes[saltos[0]][5]%7,SieteX.adyacentes[saltos[0]][5]/7)].ocupado == true &&
				         	 										SieteX.adyacentes[SieteX.adyacentes[saltos[0]][5]][5] == numCasillaCandidata)
				         	 								{
				         	 									sal_borra[numsalto] = XasociaCasilla(SieteX.adyacentes[saltos[numsalto]][5]%7,SieteX.adyacentes[saltos[numsalto]][5]/7);
				         	 									flag = true;
				         	 									if (SieteX.adyacentes[saltos[0]][5] != -1 &&
				         	 											tablero.casillas[XasociaCasilla(SieteX.adyacentes[saltos[0]][5]%7,SieteX.adyacentes[saltos[0]][5]/7)].ocupado == true &&
				         	 											SieteX.adyacentes[SieteX.adyacentes[saltos[0]][5]][5] == numCasillaCandidata)
				         	 									{
				         	 										for (int a=15; a>0; a--)
				         	 										{
				         	 											if (saltos[a] != -1)
				         	 											{
				         	 												borrarCuadro(saltos[a]%7, saltos[a]/7);
				         	 											}
				         	 										}
				         	 										inicializaSaltos();
				         	 									}
				         	 									else 
				         	 										if (flagSalto == false)
				         	 										{
				         	 											inicializaSaltos();
				         	 										}
				         	 										flagSalto = true;
				         	 										numsalto++; //Aumentamos en uno el numero de salto
				         	 										saltos[numsalto] = numCasillaCandidata;
				         	 								}
			         	 				
				         	 								else
					         	 								if (SieteX.adyacentes[saltos[0]][6] != -1 &&
					         	 										tablero.casillas[XasociaCasilla(SieteX.adyacentes[saltos[0]][6]%7,SieteX.adyacentes[saltos[0]][6]/7)].ocupado == true &&
					         	 										SieteX.adyacentes[SieteX.adyacentes[saltos[0]][6]][6] == numCasillaCandidata)
					         	 								{
					         	 									sal_borra[numsalto] = XasociaCasilla(SieteX.adyacentes[saltos[numsalto]][6]%7,SieteX.adyacentes[saltos[numsalto]][6]/7);
					         	 									flag = true;
					         	 									if (SieteX.adyacentes[saltos[0]][6] != -1 &&
					         	 											tablero.casillas[XasociaCasilla(SieteX.adyacentes[saltos[0]][6]%7,SieteX.adyacentes[saltos[0]][6]/7)].ocupado == true &&
					         	 											SieteX.adyacentes[SieteX.adyacentes[saltos[0]][6]][6] == numCasillaCandidata)
					         	 									{
					         	 										for (int a=15; a>0; a--)
					         	 										{
					         	 											if (saltos[a] != -1)
					         	 											{
					         	 												borrarCuadro(saltos[a]%7, saltos[a]/7);
					         	 											}
					         	 										}
					         	 										inicializaSaltos();
					         	 									}
					         	 									else 
					         	 										if (flagSalto == false)
					         	 										{
					         	 											inicializaSaltos();
					         	 										}
					         	 										flagSalto = true;
					         	 										numsalto++; //Aumentamos en uno el numero de salto
					         	 										saltos[numsalto] = numCasillaCandidata;
					         	 								}
					         	 								else
						         	 								if (SieteX.adyacentes[saltos[0]][7] != -1 &&
						         	 										tablero.casillas[XasociaCasilla(SieteX.adyacentes[saltos[0]][7]%7,SieteX.adyacentes[saltos[0]][7]/7)].ocupado == true &&
						         	 										SieteX.adyacentes[SieteX.adyacentes[saltos[0]][7]][7] == numCasillaCandidata)
						         	 								{
						         	 									sal_borra[numsalto] = XasociaCasilla(SieteX.adyacentes[saltos[numsalto]][7]%7,SieteX.adyacentes[saltos[numsalto]][7]/7);
						         	 									flag = true;
						         	 									if (SieteX.adyacentes[saltos[0]][7] != -1 &&
						         	 											tablero.casillas[XasociaCasilla(SieteX.adyacentes[saltos[0]][7]%7,SieteX.adyacentes[saltos[0]][7]/7)].ocupado == true &&
						         	 											SieteX.adyacentes[SieteX.adyacentes[saltos[0]][7]][7] == numCasillaCandidata)
						         	 									{
						         	 										for (int a=15; a>0; a--)
						         	 										{
						         	 											if (saltos[a] != -1)
						         	 											{
						         	 												borrarCuadro(saltos[a]%7, saltos[a]/7);
						         	 											}
						         	 										}
						         	 										inicializaSaltos();
						         	 									}
						         	 									else 
						         	 										if (flagSalto == false)
						         	 										{
						         	 											inicializaSaltos();
						         	 										}
						         	 										flagSalto = true;
						         	 										numsalto++; //Aumentamos en uno el numero de salto
						         	 										saltos[numsalto] = numCasillaCandidata;
						         	 								}
			         	 				
			         	 	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
			         	 				
	             	 			
			         	 				}

			         	 			if (flagSalto && flag)
			         	 			{
			         	 				if (numsalto == 1) //Para borrar las selecciones cuando se pivota con casillaSeleccionada
			         	 				{
			         	 					//System.out.println(numsalto);
			         	 					borrarCuadro (candidata_posi, candidata_posj);
			         	 				}
			         	 				candidata_posi = i;
			         	 				candidata_posj = j;
			         	 				dibujaCandidata(i,j);
			         	 				dibujaSeleccion(saltos[0]%7, saltos[0]/7);
			         	 				//System.out.println("salto???");
			         	 			}
	         	 			
			         	 			if(flag)
			         	 			{
	                			//Entramos aqui si ya esta seleccionada la posicion a la que
	                			//queremos mover y se esta esperando otro click ahi
	                			
	             	 			               			
	             	 		//hay ya una casilla seleccionada y la tenemos que quitar
			         	 				if (candidata_posi != -1 && candidata_posj != -1)
			         	 				{
			         	 					borrarCuadro (candidata_posi, candidata_posj);
			         	 					
			         	 				}
	                			
			         	 				candidata_posi = i;
			         	 				candidata_posj = j;
			         	 				dibujaCandidata(i,j);
			         	 				dibujaSeleccion(saltos[0]%7, saltos[0]/7);
			         	 				//System.out.println("JAVIsdfgsdf");
			         	 			}
			         	 			else
			         	 			{
			         	 				//Si el flag no esta activo no se hace nada (no hay seleccion ninguna)
			         	 			}
			             	 	}	
	             	 	
			            	}
	            }}
	    	}
	    	
		
	    	else  //caso en el que hacemos doble click
	    	{
	    		if(mouseevent.getClickCount()==2)
	    		{
	    			//System.out.println("JAVI");
	    			Graphics2D graphics2d = (Graphics2D)getGraphics();
	    			int l = mouseevent.getX();
	    			int k = mouseevent.getY();
	    			//if(l <= 20 || l >= 660 || k <=50 || k >= 690)
	    			//if(l <= 200 || l >= 800 || k <=50 || k >= 690)
	    			if(l <= 200 + 84 || l >= 662 + 84 || k <=50 || k >= 512)    
	    			{
	    				break label0;
	    			}
	            
	    			//int i = Math.round((l-20) / 80);
	    			//int i = Math.round((l-200) / 60);
			           // int j = Math.round((k-50) / 60);
			            int i=0,j=0; 
			            if (l>=200 + 84 && l<=254 + 84)
			            {
			            	if (k>=50 && k<=104)
			            	{
			            		i = 0; 
			            		j = 0;
			            	}
			            	else if (k>=118 && k<=172)
			            	{
			            		i = 0;
			            		j = 1;
			            	}
			            	else if (k>=186 && k<=240)
			            	{
			            		i = 0;
			            		j = 2;
			            	}
			            	else if (k>=254 && k<=308)
			            	{
			            		i = 0;
			            		j = 3;
			            	}
			            	else if (k>=322 && k<=376)
			            	{
			            		i = 0;
			            		j = 4;
			            	}
			            	else if (k>=390 && k<=444)
			            	{
			            		i = 0;
			            		j = 5;
			            	}
			            	else if (k>=458 && k<=512)
			            	{
			            		i = 0;
			            		j = 6;
			            	}
			            }
			            else if (l>=268 + 84 && l<=322 + 84)
			            {
			            	if (k>=50 && k<=104)
			            	{
			            		i = 1; 
			            		j = 0;
			            	}
			            	else if (k>=118 && k<=172)
			            	{
			            		i = 1;
			            		j = 1;
			            	}
			            	else if (k>=186 && k<=240)
			            	{
			            		i = 1;
			            		j = 2;
			            	}
			            	else if (k>=254 && k<=308)
			            	{
			            		i = 1;
			            		j = 3;
			            	}
			            	else if (k>=322 && k<=376)
			            	{
			            		i = 1;
			            		j = 4;
			            	}
			            	else if (k>=390 && k<=444)
			            	{
			            		i = 1;
			            		j = 5;
			            	}
			            	else if (k>=458 && k<=512)
			            	{
			            		i = 1;
			            		j = 6;
			            	}
			            }
			            else if (l>=336 + 84 && l<=390 + 84)
			            {
			            	if (k>=50 && k<=104)
			            	{
			            		i = 2; 
			            		j = 0;
			            	}
			            	else if (k>=118 && k<=172)
			            	{
			            		i = 2;
			            		j = 1;
			            	}
			            	else if (k>=186 && k<=240)
			            	{
			            		i = 2;
			            		j = 2;
			            	}
			            	else if (k>=254 && k<=308)
			            	{
			            		i = 2;
			            		j = 3;
			            	}
			            	else if (k>=322 && k<=376)
			            	{
			            		i = 2;
			            		j = 4;
			            	}
			            	else if (k>=390 && k<=444)
			            	{
			            		i = 2;
			            		j = 5;
			            	}
			            	else if (k>=458 && k<=512)
			            	{
			            		i = 2;
			            		j = 6;
			            	}
			            }
			            else if (l>=404 + 84 && l<=458 + 84)
			            {
			            	if (k>=50 && k<=104)
			            	{
			            		i = 3; 
			            		j = 0;
			            	}
			            	else if (k>=118 && k<=172)
			            	{
			            		i = 3;
			            		j = 1;
			            	}
			            	else if (k>=186 && k<=240)
			            	{
			            		i = 3;
			            		j = 2;
			            	}
			            	else if (k>=254 && k<=308)
			            	{
			            		i = 3;
			            		j = 3;
			            	}
			            	else if (k>=322 && k<=376)
			            	{
			            		i = 3;
			            		j = 4;
			            	}
			            	else if (k>=390 && k<=444)
			            	{
			            		i = 3;
			            		j = 5;
			            	}
			            	else if (k>=458 && k<=512)
			            	{
			            		i = 3;
			            		j = 6;
			            	}
			            }
			            else if (l>=472 + 84 && l<=526 + 84)
			            {
			            	if (k>=50 && k<=104)
			            	{
			            		i = 4; 
			            		j = 0;
			            	}
			            	else if (k>=118 && k<=172)
			            	{
			            		i = 4;
			            		j = 1;
			            	}
			            	else if (k>=186 && k<=240)
			            	{
			            		i = 4;
			            		j = 2;
			            	}
			            	else if (k>=254 && k<=308)
			            	{
			            		i = 4;
			            		j = 3;
			            	}
			            	else if (k>=322 && k<=376)
			            	{
			            		i = 4;
			            		j = 4;
			            	}
			            	else if (k>=390 && k<=444)
			            	{
			            		i = 4;
			            		j = 5;
			            	}
			            	else if (k>=458 && k<=512)
			            	{
			            		i = 4;
			            		j = 6;
			            	}
			            }
			            else if (l>=540 + 84 && l<=594 + 84)
			            {
			            	if (k>=50 && k<=104)
			            	{
			            		i = 5; 
			            		j = 0;
			            	}
			            	else if (k>=118 && k<=172)
			            	{
			            		i = 5;
			            		j = 1;
			            	}
			            	else if (k>=186 && k<=240)
			            	{
			            		i = 5;
			            		j = 2;
			            	}
			            	else if (k>=254 && k<=308)
			            	{
			            		i = 5;
			            		j = 3;
			            	}
			            	else if (k>=322 && k<=376)
			            	{
			            		i = 5;
			            		j = 4;
			            	}
			            	else if (k>=390 && k<=444)
			            	{
			            		i = 5;
			            		j = 5;
			            	}
			            	else if (k>=458 && k<=512)
			            	{
			            		i = 5;
			            		j = 6;
			            	}
			            }
			            else if (l>=608 + 84 && l<=662 + 84)
			            {
			            	if (k>=50 && k<=104)
			            	{
			            		i = 6; 
			            		j = 0;
			            	}
			            	else if (k>=118 && k<=172)
			            	{
			            		i = 6;
			            		j = 1;
			            	}
			            	else if (k>=186 && k<=240)
			            	{
			            		i = 6;
			            		j = 2;
			            	}
			            	else if (k>=254 && k<=308)
			            	{
			            		i = 6;
			            		j = 3;
			            	}
			            	else if (k>=322 && k<=376)
			            	{
			            		i = 6;
			            		j = 4;
			            	}
			            	else if (k>=390 && k<=444)
			            	{
			            		i = 6;
			            		j = 5;
			            	}
			            	else if (k>=458 && k<=512)
			            	{
			            		i = 6;
			            		j = 6;
			            	}
			            } 
	    			
	            //caso en el que no haya ninguna casilla seleccionada
	            if(seleccionada_posi == -1 && seleccionada_posj == -1)	
	            {
	            	break label0;
	            }
	            
	            //Habiendo una seleccionada, hacemos doble click en otra casilla
	    		if(seleccionada_posi != i || seleccionada_posj != j)
	            {
	    			borrarCuadro (candidata_posi, candidata_posj); // Para evitar que se quede una casilla candidata
	    							//dibujada cuando se hace un doble click incorrecto
	    			
	    			//actualizamos los indices de la casilla seleccionada
	    			candidata_posi = i;
	    			candidata_posj = j;
	    		
	    			if(flag)//se puede realizar el movimiento
	              	{
	    				if(!flagSalto)
	    				{
	    					for (int a=0; a<16; a++)
	                        {
	                        	if (saltos[a] != -1)
	                        	{
	                        		borrarCuadro(saltos[a]%7, saltos[a]/7);
	                        	}
	                        }
	    				}
	    				
	    				numCasillaSeleccionada = XasociaCasilla(seleccionada_posi, seleccionada_posj);
	    				numCasillaCandidata = XasociaCasilla(candidata_posi, candidata_posj);
	    				dibujaCandidata(i,j);
	    				numsalto = 0;
	    				if(flagSalto)
	                    {
	    					
	                    	for (int a=1; a<16; a++)
	                    	{
	                    		if (saltos[a-1] != -1 && saltos[a] != -1)
	                    		{
	                    			borrarCuadro(saltos[a-1]%7, saltos[a-1]/7);
	                    			parpadeo();
	                    			borrarCuadro(sal_borra[a-1]%7, sal_borra[a-1]/7);
	                    			pintarPieza(tablero.casillas[numCasillaSeleccionada].numjugador, saltos[a]/7, saltos[a]%7, true);
	                    			//borrarCuadro(sal_borra[a-1]%5, sal_borra[a-1]/5);
	                    			numsalto++;
	                    			
	                    			parpadeo(); //Relentiza el proceso de dibujar los saltos
	                    			
	                    		}
	                    	}
	                    }
	                  
	    				borrarCuadro(seleccionada_posi, seleccionada_posj);
	    				
	    				//casilla_borrar = asociaCasilla(sal_borra[0]%5, sal_borra[0]/5);
	    				
	    				for (int a=0; a<16; a++)
	    				{
	    					//System.out.print(asociaCasilla(sal_borra[a]%5,sal_borra[a]/5) + ", ");
	    					if (sal_borra[a] != -1)
	    						vector_aux [a] = XasociaCasilla(sal_borra[a]%7, sal_borra[a]/7);
	    				}
	    				/*
	    				for (int a=0; a<16; a++)
	    					if (sal_borra[a] != -1)
	    						borrarCuadro(sal_borra[a]%5, sal_borra[a]/5);
	                	*/
	    				pintarPieza(tablero.casillas[numCasillaSeleccionada].numjugador, candidata_posj, candidata_posi, true);
	    				
	
	///////////////////////////////////    				///////////////////////////////
	                    //mover(numCasillaSeleccionada, numCasillaCandidata, casilla_borrar);
	                    mover(numCasillaSeleccionada, numCasillaCandidata, vector_aux);
	                    for (int a = 0; a<16;a++){
	                    	vector_aux[a] = -1;
	                    	sal_borra[a] = -1;
	                    }
	     ////////////////////////////////////////////////                    /////////////////////////////
	                    if(compruebaGanador()!=0)
	                    {
	                    	detenerJuego = true;
	                    	muestraGanador();
	                    }
	                    
	                    seleccionada_posj = -1;
	                    seleccionada_posi = -1;	
	                    candidata_posi = -1;
	                    candidata_posj = -1;
	                    inicializaSaltos();
	                    saltos[0]= -1; //Desanclamos el numCasillaSeleccionada, ya se se mueve la ficha
	                    flagSalto =false;
	                    flag = false;
	                    numsalto = 0;
	                    if(tablero.jugadores[turno-1].esPC && !detenerJuego)
	            		{
	            			mover_pc();
	            		}
	                    
	                    break label0;
	              	}
	              	else //no se puede realizar el movimiento
	              	{
	              		lAviso.setText("¡ERROR! El movimiento es incorrecto, no se puede realizar");
	              		
	              		/////////////////////SONIDOOOOOOOOOOOOOOOOOOOOOOOOO
	              		//soni.playSound("Sonido/Error.wav");
	              		////////////////////////////////////////////////
	              	}          	  
	      
	    	  		}
	    		}
	   
	    	}
		
			}//FIN TIPOTABL == 2
		 	if (tipotabl == 6)
			{
				if(tablero.jugadores[turno-1].esPC && cuentaEmpezar==0)
			 	{
			 		cuentaEmpezar = 1;
		        	tiempo.start();
			 	}	 	
	    	
	    	//caso en el que hacemos un solo click
			 	if(mouseevent.getClickCount() == 1)
		    	{    		
		    		Graphics2D graphics2d = (Graphics2D)getGraphics();
		            int l = mouseevent.getX();
		            int k = mouseevent.getY();
		            
		            //if(l <= 20 || l >= 660 || k <=50 || k >= 690)
		            //if(l <= 200 || l >= 800 || k <=50 || k >= 690)
		            if(l <= 200 + 84 || l >= 662 + 84 || k <=50 || k >= 512)
		            	break label0;
	            
		            detenerJuego = false;
		            
		            if(compruebaGanador()!= 0)
		            {
		            	detenerJuego = true;
		            }
		            
		            if(tablero.jugadores[turno-1].esPC)
		            {
		            	mover_pc();
		            	
		            	if(detenerJuego)//Implica que se ha terminado la partida
		            	{
		            		muestraGanador();
		            	}
	                       	
		            }
		            
	///// MIRAR TODO ESTO LOS BUCLES Y TAL Y TAL ////////////////////////////////////
		            // No es PC, es jugador normal.
		            else
		            {
			            //Calcula la coordenada i,j del tablero (16x16) que se pincha
			            //int i = Math.round((l-20) / 80);
		            	//int i = Math.round((l-200) / 60);
				           // int j = Math.round((k-50) / 60);
		            	int i=8,j=8; 
			            if (l>=200 + 84 && l<=254 + 84)
			            {
			            	if (k>=50 && k<=104)
			            	{
			            		i = 0; 
			            		j = 0;
			            	}
			            	else if (k>=118 && k<=172)
			            	{
			            		i = 0;
			            		j = 1;
			            	}
			            	else if (k>=186 && k<=240)
			            	{
			            		i = 0;
			            		j = 2;
			            	}
			            	else if (k>=254 && k<=308)
			            	{
			            		i = 0;
			            		j = 3;
			            	}
			            	else if (k>=322 && k<=376)
			            	{
			            		i = 0;
			            		j = 4;
			            	}
			            	else if (k>=390 && k<=444)
			            	{
			            		i = 0;
			            		j = 5;
			            	}
			            	else if (k>=458 && k<=512)
			            	{
			            		i = 0;
			            		j = 6;
			            	}
			            }
			            else if (l>=268 + 84 && l<=322 + 84)
			            {
			            	if (k>=50 && k<=104)
			            	{
			            		i = 1; 
			            		j = 0;
			            	}
			            	else if (k>=118 && k<=172)
			            	{
			            		i = 1;
			            		j = 1;
			            	}
			            	else if (k>=186 && k<=240)
			            	{
			            		i = 1;
			            		j = 2;
			            	}
			            	else if (k>=254 && k<=308)
			            	{
			            		i = 1;
			            		j = 3;
			            	}
			            	else if (k>=322 && k<=376)
			            	{
			            		i = 1;
			            		j = 4;
			            	}
			            	else if (k>=390 && k<=444)
			            	{
			            		i = 1;
			            		j = 5;
			            	}
			            	else if (k>=458 && k<=512)
			            	{
			            		i = 1;
			            		j = 6;
			            	}
			            }
			            else if (l>=336 + 84 && l<=390 + 84)
			            {
			            	if (k>=50 && k<=104)
			            	{
			            		i = 2; 
			            		j = 0;
			            	}
			            	else if (k>=118 && k<=172)
			            	{
			            		i = 2;
			            		j = 1;
			            	}
			            	else if (k>=186 && k<=240)
			            	{
			            		i = 2;
			            		j = 2;
			            	}
			            	else if (k>=254 && k<=308)
			            	{
			            		i = 2;
			            		j = 3;
			            	}
			            	else if (k>=322 && k<=376)
			            	{
			            		i = 2;
			            		j = 4;
			            	}
			            	else if (k>=390 && k<=444)
			            	{
			            		i = 2;
			            		j = 5;
			            	}
			            	else if (k>=458 && k<=512)
			            	{
			            		i = 2;
			            		j = 6;
			            	}
			            }
			            else if (l>=404 + 84 && l<=458 + 84)
			            {
			            	if (k>=50 && k<=104)
			            	{
			            		i = 3; 
			            		j = 0;
			            	}
			            	else if (k>=118 && k<=172)
			            	{
			            		i = 3;
			            		j = 1;
			            	}
			            	else if (k>=186 && k<=240)
			            	{
			            		i = 3;
			            		j = 2;
			            	}
			            	else if (k>=254 && k<=308)
			            	{
			            		i = 3;
			            		j = 3;
			            	}
			            	else if (k>=322 && k<=376)
			            	{
			            		i = 3;
			            		j = 4;
			            	}
			            	else if (k>=390 && k<=444)
			            	{
			            		i = 3;
			            		j = 5;
			            	}
			            	else if (k>=458 && k<=512)
			            	{
			            		i = 3;
			            		j = 6;
			            	}
			            }
			            else if (l>=472 + 84 && l<=526 + 84)
			            {
			            	if (k>=50 && k<=104)
			            	{
			            		i = 4; 
			            		j = 0;
			            	}
			            	else if (k>=118 && k<=172)
			            	{
			            		i = 4;
			            		j = 1;
			            	}
			            	else if (k>=186 && k<=240)
			            	{
			            		i = 4;
			            		j = 2;
			            	}
			            	else if (k>=254 && k<=308)
			            	{
			            		i = 4;
			            		j = 3;
			            	}
			            	else if (k>=322 && k<=376)
			            	{
			            		i = 4;
			            		j = 4;
			            	}
			            	else if (k>=390 && k<=444)
			            	{
			            		i = 4;
			            		j = 5;
			            	}
			            	else if (k>=458 && k<=512)
			            	{
			            		i = 4;
			            		j = 6;
			            	}
			            }
			            else if (l>=540 + 84 && l<=594 + 84)
			            {
			            	if (k>=50 && k<=104)
			            	{
			            		i = 5; 
			            		j = 0;
			            	}
			            	else if (k>=118 && k<=172)
			            	{
			            		i = 5;
			            		j = 1;
			            	}
			            	else if (k>=186 && k<=240)
			            	{
			            		i = 5;
			            		j = 2;
			            	}
			            	else if (k>=254 && k<=308)
			            	{
			            		i = 5;
			            		j = 3;
			            	}
			            	else if (k>=322 && k<=376)
			            	{
			            		i = 5;
			            		j = 4;
			            	}
			            	else if (k>=390 && k<=444)
			            	{
			            		i = 5;
			            		j = 5;
			            	}
			            	else if (k>=458 && k<=512)
			            	{
			            		i = 5;
			            		j = 6;
			            	}
			            }
			            else if (l>=608 + 84 && l<=662 + 84)
			            {
			            	if (k>=50 && k<=104)
			            	{
			            		i = 6; 
			            		j = 0;
			            	}
			            	else if (k>=118 && k<=172)
			            	{
			            		i = 6;
			            		j = 1;
			            	}
			            	else if (k>=186 && k<=240)
			            	{
			            		i = 6;
			            		j = 2;
			            	}
			            	else if (k>=254 && k<=308)
			            	{
			            		i = 6;
			            		j = 3;
			            	}
			            	else if (k>=322 && k<=376)
			            	{
			            		i = 6;
			            		j = 4;
			            	}
			            	else if (k>=390 && k<=444)
			            	{
			            		i = 6;
			            		j = 5;
			            	}
			            	else if (k>=458 && k<=512)
			            	{
			            		i = 6;
			            		j = 6;
			            	}
			            } 
		                     
			          //Si deseleccionamos la casilla seleccionada
			            if(seleccionada_posi == i && seleccionada_posj == j)
			            {
			                if(flagSalto)
			                {
			                	for (int a=15; a>0; a--)
			                	{
			                		if (saltos[a] != -1)
			                		{
			                			borrarCuadro(saltos[a]%7, saltos[a]/7);
			                		}
			                	}
			                }
	            	
			            	borrarCuadro(i, j);
			                borrarCuadro (candidata_posi, candidata_posj);
			                pintarPieza(tablero.casillas[XasociaCasilla(i,j)].numjugador, j, i, true);
			              
			                seleccionada_posj = -1;
			                seleccionada_posi = -1;	
			                candidata_posi = -1;
			                candidata_posj = -1;
			                
			                inicializaSaltos();
			                
			                saltos[0]= -1;
			                sal_borra[0] = -1;
			                vector_aux[0]=-1;
			                
			                break label0;
			            }            
	            
			            //Cuando seleccionamos
			            if(seleccionada_posi == -1 && seleccionada_posj == -1)
			            {	
			            	if (i>7 && j >7)
			            	{
			            		break label0;
			            	}
			            	//Si pinchamos en una casilla sin ficha (sin que haya nada seleccionado)
			            	if (tablero.casillas[XasociaCasilla(i,j)].ocupado == false)
			                    break label0;
		            	
			            	//Si pinchamos para seleccionar en una ficha cuyo turno no corresponde
			            	if(tablero.casillas[XasociaCasilla(i,j)].numjugador != turno)
			            		break label0;
		            	
			                seleccionada_posi = i;
			                seleccionada_posj = j;
		                               
		                
			                //Para comenzar el tiempo la primera vez que pinchemos
			                if(cuentaEmpezar==0)
			                {	
			                	cuentaEmpezar = 1;
			                	tiempo.start();
			                }
			              
			                dibujaSeleccion(i, j);
			                
			                saltos[0] = XasociaCasilla(seleccionada_posi, seleccionada_posj); 
			                //System.out.println("buaahh " + saltos[0]);
			            }
			            
			            else //Caso en el que haya una ficha seleccionada y pincha en otra casilla 
			            {
			            	if (i>7 && j >7)
			            	{
			            		if(flagSalto)
				                {
				                	for (int a=15; a>0; a--)
				                	{
				                		if (saltos[a] != -1)
				                		{
				                			borrarCuadro(saltos[a]%7, saltos[a]/7);
				                		}
				                	}
				                }
		            	
				            	borrarCuadro(i, j);
				                borrarCuadro (candidata_posi, candidata_posj);
				                borrarCuadro (i, j);
				                pintarPieza(tablero.casillas[XasociaCasilla(seleccionada_posi,seleccionada_posj)].numjugador, seleccionada_posj, seleccionada_posi, true);
				                seleccionada_posj = -1;
				                seleccionada_posi = -1;	
				                inicializaSaltos();
				                saltos[0]= -1;
				                sal_borra[0] = -1;
				                vector_aux[0]=-1;
			            		break label0;
			            	}
			            	if(seleccionada_posi != i || seleccionada_posj != j)
			            	{            		
			             	 	if(tablero.casillas[XasociaCasilla(i,j)].ocupado == false)
			             	 	{ 
	//Se activa cuando hay posibilidad de movimiento (espera un nuevo click a esa posicion para ejecutar el cambio)
	             	 	            flag = false;
			             	 	    numCasillaCandidata = XasociaCasilla(i, j);
			         	 			numCasillaSeleccionada = XasociaCasilla(seleccionada_posi, seleccionada_posj);
			         	 			if (saltos[0] == -1)
			         	 			{
			         	 				saltos[0] = numCasillaSeleccionada; //La casilla seleccionada de verdad
			         	 				System.out.println("la casilla d verdad " + saltos[0]);
			         	 			}
	         	 			
			         	 			if(tablero.casillas[numCasillaSeleccionada].numjugador == 1)
			         	 			{
			         	 				//Tratamos el movimiento simple (para el jugador 1 y para el jugador 3)
			         	 				
			         	 			////////////////////////////////////////////////
			         	 				//MIOOOOOOOOOOOOOOOOO
			         	 			//////////////////////////////////////////////////
			         	 				if (SieteX_restri.adyacentes[numCasillaSeleccionada][0] == numCasillaCandidata)
			         	 				{
			         	 					for (int a=15; a>0; a--)
			         	 					{
			         	 						if (saltos[a] != -1)
			         	 						{
			         	 							borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 						}
			         	 					}
			                 	 			flag = true;
			                 	 			flagSalto = false;
			                 	 			inicializaSaltos();
			         	 				}
			         	 				else
			         	 					if (SieteX_restri.adyacentes[numCasillaSeleccionada][1] == numCasillaCandidata)
				         	 				{
				         	 					for (int a=15; a>0; a--)
				         	 					{
				         	 						if (saltos[a] != -1)
				         	 						{
				         	 							borrarCuadro(saltos[a]%7, saltos[a]/7);
				         	 						}
				         	 					}
				                 	 			flag = true;
				                 	 			flagSalto = false;
				                 	 			inicializaSaltos();
				         	 				}
			         	 					else
			         	 						if (SieteX_restri.adyacentes[numCasillaSeleccionada][2] == numCasillaCandidata)
					         	 				{
					         	 					for (int a=15; a>0; a--)
					         	 					{
					         	 						if (saltos[a] != -1)
					         	 						{
					         	 							borrarCuadro(saltos[a]%7, saltos[a]/7);
					         	 						}
					         	 					}
					                 	 			flag = true;
					                 	 			flagSalto = false;
					                 	 			inicializaSaltos();
					         	 				}
			         	 						else
			         	 				
			   //////////////////////////////////////////////////////////////////////////////////////////////
			         	 				
			         	 				
			         	 				
			         	 				if (SieteX_restri.adyacentes[numCasillaSeleccionada][3] == numCasillaCandidata)
			         	 				{
			         	 					for (int a=15; a>0; a--)
			         	 					{
			         	 						if (saltos[a] != -1)
			         	 						{
			         	 							borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 						}
			         	 					}
			                 	 			flag = true;
			                 	 			flagSalto = false;
			                 	 			inicializaSaltos();
			         	 				}
			         	 				
			         	 				else 
			         	 					if (SieteX_restri.adyacentes[numCasillaSeleccionada][4] == numCasillaCandidata)
			         	 					{
			         	 						for (int a=15; a>0; a--)
			         	 						{
			         	 							if (saltos[a] != -1)
			         	 							{
			         	 								borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 							}
			         	 						}
			         	 						flag = true;
			         	 						flagSalto = false;
			         	 						inicializaSaltos();
			         	 					}
			         	 					else 
			         	 						if (SieteX_restri.adyacentes[numCasillaSeleccionada][5] == numCasillaCandidata)
			         	 						{
			         	 							for (int a=15; a>0; a--)
			         	 							{
			         	 								if (saltos[a] != -1)
			         	 								{
			         	 									borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 								}
			         	 							}
			         	 							flag = true;
			         	 							flagSalto = false;
			         	 							inicializaSaltos();
			         	 						}
			         	 						else 
			         	 							if (SieteX_restri.adyacentes[numCasillaSeleccionada][6] == numCasillaCandidata)
			         	 							{
			         	 								for (int a=15; a>0; a--)
			         	 								{
			         	 									if (saltos[a] != -1)
			         	 									{
			         	 										borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 									}
			         	 								}
			         	 								flag = true;
			         	 								flagSalto = false;
			         	 								inicializaSaltos();
			         	 							}
			         	 							else 
			         	 								if (SieteX_restri.adyacentes[numCasillaSeleccionada][7] == numCasillaCandidata)
			         	 								{
			         	 									for (int a=15; a>0; a--)
			         	 									{
			         	 										if (saltos[a] != -1)
			         	 										{
			         	 											borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 										}
			         	 									}
			         	 									flag = true;
			         	 									flagSalto = false;
			         	 									inicializaSaltos();
			         	 								}
	             	 			
			         	 			}
	          	 		
			         	 			else 
			         	 				if(tablero.casillas[numCasillaSeleccionada].numjugador == 2)
			         	 						//|| tablero.casillas[numCasillaSeleccionada].numjugador == 4)
			         	 				{
	             	 			//Tratamos el movimiento simple (para el jugador 2 y para el jugador 4)
	             	 			
			         	 					if (SieteX_restri.adyacentes[numCasillaSeleccionada][0] == numCasillaCandidata)
			         	 					{
			         	 						for (int a=15; a>0; a--)
			         	 						{
			         	 							if (saltos[a] != -1)
			         	 							{
			         	 								borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 							}
			         	 						}
			         	 						flag = true;
			         	 						flagSalto = false;
			         	 						inicializaSaltos();
			         	 					}
			         	 					else 
			         	 						if (SieteX_restri.adyacentes[numCasillaSeleccionada][1] == numCasillaCandidata)
			         	 						{
			         	 							for (int a=15; a>0; a--)
			         	 							{
			         	 								if (saltos[a] != -1)
			         	 								{
			         	 									borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 								}
			         	 							}
			         	 							flag = true;
			         	 							flagSalto = false;
			         	 							inicializaSaltos();
			         	 						}
			         	 						else 
			         	 							if (SieteX_restri.adyacentes[numCasillaSeleccionada][2] == numCasillaCandidata)
			         	 							{
			         	 								for (int a=15; a>0; a--)
			         	 								{
			         	 									if (saltos[a] != -1)
			         	 									{
			         	 										borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 									}
			         	 								}
			         	 								flag = true;
			         	 								flagSalto = false;
			         	 								inicializaSaltos();
			         	 							}
			         	 							else 
			         	 								if (SieteX_restri.adyacentes[numCasillaSeleccionada][3] == numCasillaCandidata)
			         	 								{
			         	 									for (int a=15; a>0; a--)
			         	 									{
			         	 										if (saltos[a] != -1)
			         	 										{
			         	 											borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 										}
			         	 									}
			         	 									flag = true;
			         	 									flagSalto = false;
			         	 									inicializaSaltos();
			         	 								}
			         	 								else 
			         	 									if (SieteX_restri.adyacentes[numCasillaSeleccionada][4] == numCasillaCandidata)
			         	 									{
			         	 										for (int a=15; a>0; a--)
			         	 										{
			         	 											if (saltos[a] != -1)
			         	 											{
			         	 												borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 											}
			         	 										}
			         	 										flag = true;
			         	 										flagSalto = false;
			         	 										inicializaSaltos();
			         	 									}
			         	 					
			         	 ////////////////////////////////////////////////////////////////////////////////
			         	 					//MIOOOOOOOOOOOOOOOOOOOOOOOO
			         	 ////////////////////////////////////////////////////////////////////////////////					
	             	 			
			         	 									else 
				         	 									if (SieteX_restri.adyacentes[numCasillaSeleccionada][5] == numCasillaCandidata)
				         	 									{
				         	 										for (int a=15; a>0; a--)
				         	 										{
				         	 											if (saltos[a] != -1)
				         	 											{
				         	 												borrarCuadro(saltos[a]%7, saltos[a]/7);
				         	 											}
				         	 										}
				         	 										flag = true;
				         	 										flagSalto = false;
				         	 										inicializaSaltos();
				         	 									}
				         	 									else 
					         	 									if (SieteX_restri.adyacentes[numCasillaSeleccionada][6] == numCasillaCandidata)
					         	 									{
					         	 										for (int a=15; a>0; a--)
					         	 										{
					         	 											if (saltos[a] != -1)
					         	 											{
					         	 												borrarCuadro(saltos[a]%7, saltos[a]/7);
					         	 											}
					         	 										}
					         	 										flag = true;
					         	 										flagSalto = false;
					         	 										inicializaSaltos();
					         	 									}
					         	 									else 
						         	 									if (SieteX_restri.adyacentes[numCasillaSeleccionada][7] == numCasillaCandidata)
						         	 									{
						         	 										for (int a=15; a>0; a--)
						         	 										{
						         	 											if (saltos[a] != -1)
						         	 											{
						         	 												borrarCuadro(saltos[a]%7, saltos[a]/7);
						         	 											}
						         	 										}
						         	 										flag = true;
						         	 										flagSalto = false;
						         	 										inicializaSaltos();
						         	 									}
			         	 	////////////////////////////////////////////////////////////////////////////////////////////////////////////				
			         	 					
			         	 					//Tratamos la situacion de un salto (para el jugador 2 y para el jugador 4)
	             	 			
			         	 				if (SieteX_restri.adyacentes[saltos[0]][0] != -1 &&
			         	 						tablero.casillas[XasociaCasilla(SieteX_restri.adyacentes[saltos[0]][0]%7,SieteX_restri.adyacentes[saltos[0]][0]/7)].ocupado == true &&
			         	 						SieteX_restri.adyacentes[SieteX_restri.adyacentes[saltos[0]][0]][0] == numCasillaCandidata)
			         	 				{
			         	 					sal_borra[numsalto] = XasociaCasilla(SieteX_restri.adyacentes[saltos[numsalto]][0]%7,SieteX_restri.adyacentes[saltos[numsalto]][0]/7);
			         	 					flag = true;
			         	 					if (SieteX_restri.adyacentes[saltos[0]][0] != -1 &&
			         	 						tablero.casillas[XasociaCasilla(SieteX_restri.adyacentes[saltos[0]][0]%7,SieteX_restri.adyacentes[saltos[0]][0]/7)].ocupado == true &&
			         	 						SieteX_restri.adyacentes[SieteX_restri.adyacentes[saltos[0]][0]][0] == numCasillaCandidata)
			         	 					{
			         	 						for (int a=15; a>0; a--)
			         	 						{
			         	 							if (saltos[a] != -1)
			         	 							{
			         	 								borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 							}
			         	 						}
			         	 						inicializaSaltos();
			         	 					}
			         	 					else
			         	 						if (flagSalto == false)
			         	 						{
			         	 							inicializaSaltos();
			         	 						}
			         	 						flagSalto = true;
			         	 						numsalto++; //Aumentamos en uno el numero de salto
			         	 						saltos[numsalto] = numCasillaCandidata;
			         	 				}
			         	 				else 
			         	 					if (SieteX_restri.adyacentes[saltos[0]][1] != -1 &&
			         	 							tablero.casillas[XasociaCasilla(SieteX_restri.adyacentes[saltos[0]][1]%7,SieteX_restri.adyacentes[saltos[0]][1]/7)].ocupado == true &&
			         	 							SieteX_restri.adyacentes[SieteX_restri.adyacentes[saltos[0]][1]][1] == numCasillaCandidata)
			         	 					{
			         	 						sal_borra[numsalto] = XasociaCasilla(SieteX_restri.adyacentes[saltos[numsalto]][1]%7,SieteX_restri.adyacentes[saltos[numsalto]][1]/7);
			         	 						flag = true;
			         	 						if (SieteX_restri.adyacentes[saltos[0]][1] != -1 &&
			         	 								tablero.casillas[XasociaCasilla(SieteX_restri.adyacentes[saltos[0]][1]%7,SieteX_restri.adyacentes[saltos[0]][1]/7)].ocupado == true &&
			         	 								SieteX_restri.adyacentes[SieteX_restri.adyacentes[saltos[0]][1]][1] == numCasillaCandidata)
			         	 						{
			         	 							for (int a=15; a>0; a--)
			         	 							{
			         	 								if (saltos[a] != -1)
			         	 								{
			         	 									borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 								}
			         	 							}
			         	 							inicializaSaltos();
			         	 						}
			         	 						else 
			         	 							if (flagSalto == false)
			         	 							{
			         	 								inicializaSaltos();
			         	 							}
			         	 							flagSalto = true;
			         	 							numsalto++; //Aumentamos en uno el numero de salto
			         	 							saltos[numsalto] = numCasillaCandidata;
			         	 					}
			         	 					else 
			         	 						if (SieteX_restri.adyacentes[saltos[0]][2] != -1 &&
			         	 								tablero.casillas[XasociaCasilla(SieteX_restri.adyacentes[saltos[0]][2]%7,SieteX_restri.adyacentes[saltos[0]][2]/7)].ocupado == true &&
			         	 								SieteX_restri.adyacentes[SieteX_restri.adyacentes[saltos[0]][2]][2] == numCasillaCandidata)
			         	 						{
			         	 							sal_borra[numsalto] = XasociaCasilla(SieteX_restri.adyacentes[saltos[numsalto]][2]%7,SieteX_restri.adyacentes[saltos[numsalto]][2]/7);
			         	 							flag = true;
			         	 							if (SieteX_restri.adyacentes[saltos[0]][2] != -1 &&
			         	 									tablero.casillas[XasociaCasilla(SieteX_restri.adyacentes[saltos[0]][2]%7,SieteX_restri.adyacentes[saltos[0]][2]/7)].ocupado == true &&
			         	 									SieteX_restri.adyacentes[SieteX_restri.adyacentes[saltos[0]][2]][2] == numCasillaCandidata)
			         	 							{
			         	 								for (int a=15; a>0; a--)
			         	 								{
			         	 									if (saltos[a] != -1)
			         	 									{
			         	 										borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 									}
			         	 								}
			         	 								inicializaSaltos();
			         	 							}
			         	 							else 
			         	 								if (flagSalto == false)
			         	 								{
			         	 									inicializaSaltos();
			         	 								}
			         	 								flagSalto = true;
			         	 								numsalto++; //Aumentamos en uno el numero de salto
			         	 								saltos[numsalto] = numCasillaCandidata;
			         	 						}
			         	 						else 
			         	 							if (SieteX_restri.adyacentes[saltos[0]][3] != -1 &&
			         	 									tablero.casillas[XasociaCasilla(SieteX_restri.adyacentes[saltos[0]][3]%7,SieteX_restri.adyacentes[saltos[0]][3]/7)].ocupado == true &&
			         	 									SieteX_restri.adyacentes[SieteX_restri.adyacentes[saltos[0]][3]][3] == numCasillaCandidata)
			         	 							{
			         	 								System.out.println("Saltos 0 vale " + saltos[0]);
			         	 								System.out.println("Saltos numsalto vale " + saltos[numsalto]);
			         	 								System.out.println("el %16 vale " + SieteX_restri.adyacentes[saltos[numsalto]][3]%7 + " y el /16 vale " + SieteX_restri.adyacentes[saltos[numsalto]][3]/7);
			         	 								
			         	 								sal_borra[numsalto] = XasociaCasilla(SieteX_restri.adyacentes[saltos[numsalto]][3]%7,SieteX_restri.adyacentes[saltos[numsalto]][3]/7);
			         	 								System.out.println("El valor de sal_borra[0] es " + sal_borra[0]);
			         	 								System.out.println("num salto vale " + numsalto);
			         	 								flag = true;
			         	 								if (SieteX_restri.adyacentes[saltos[0]][3] != -1 &&
			         	 										tablero.casillas[XasociaCasilla(SieteX_restri.adyacentes[saltos[0]][3]%7,SieteX_restri.adyacentes[saltos[0]][3]/7)].ocupado == true &&
			         	 										SieteX_restri.adyacentes[SieteX_restri.adyacentes[saltos[0]][3]][3] == numCasillaCandidata)
			         	 								{
			         	 									for (int a=15; a>0; a--)
			         	 									{
			         	 										if (saltos[a] != -1)
			         	 										{
			         	 											borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 										}
			         	 			        				}
			         	 									inicializaSaltos();
			         	 								}
			         	 								else 
			         	 									if (flagSalto == false)
			         	 									{
			         	 										inicializaSaltos();
			         	 									}
			         	 									flagSalto = true;
			         	 									numsalto++; //Aumentamos en uno el numero de salto
			         	 									saltos[numsalto] = numCasillaCandidata;
			         	 							}
			         	 							else
			         	 								if (SieteX_restri.adyacentes[saltos[0]][4] != -1 &&
			         	 										tablero.casillas[XasociaCasilla(SieteX_restri.adyacentes[saltos[0]][4]%7,SieteX_restri.adyacentes[saltos[0]][4]/7)].ocupado == true &&
			         	 										SieteX_restri.adyacentes[SieteX_restri.adyacentes[saltos[0]][4]][4] == numCasillaCandidata)
			         	 								{
			         	 									sal_borra[numsalto] = XasociaCasilla(SieteX_restri.adyacentes[saltos[numsalto]][4]%7,SieteX_restri.adyacentes[saltos[numsalto]][4]/7);
			         	 									flag = true;
			         	 									if (SieteX_restri.adyacentes[saltos[0]][4] != -1 &&
			         	 											tablero.casillas[XasociaCasilla(SieteX_restri.adyacentes[saltos[0]][4]%7,SieteX_restri.adyacentes[saltos[0]][4]/7)].ocupado == true &&
			         	 											SieteX_restri.adyacentes[SieteX_restri.adyacentes[saltos[0]][4]][4] == numCasillaCandidata)
			         	 									{
			         	 										for (int a=15; a>0; a--)
			         	 										{
			         	 											if (saltos[a] != -1)
			         	 											{
			         	 												borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 											}
			         	 										}
			         	 										inicializaSaltos();
			         	 									}
			         	 									else 
			         	 										if (flagSalto == false)
			         	 										{
			         	 											inicializaSaltos();
			         	 										}
			         	 										flagSalto = true;
			         	 										numsalto++; //Aumentamos en uno el numero de salto
			         	 										saltos[numsalto] = numCasillaCandidata;
			         	 								}
			         	 				
			       ////////////////////////////////////////////////////////////////////////////
			         	 				//MIO
			       /////////////////////////////////////////////////////////////////////////////
			         	 				
			         	 								else
				         	 								if (SieteX_restri.adyacentes[saltos[0]][5] != -1 &&
				         	 										tablero.casillas[XasociaCasilla(SieteX_restri.adyacentes[saltos[0]][5]%7,SieteX_restri.adyacentes[saltos[0]][5]/7)].ocupado == true &&
				         	 										SieteX_restri.adyacentes[SieteX_restri.adyacentes[saltos[0]][5]][5] == numCasillaCandidata)
				         	 								{
				         	 									sal_borra[numsalto] = XasociaCasilla(SieteX_restri.adyacentes[saltos[numsalto]][5]%7,SieteX_restri.adyacentes[saltos[numsalto]][5]/7);
				         	 									flag = true;
				         	 									if (SieteX_restri.adyacentes[saltos[0]][5] != -1 &&
				         	 											tablero.casillas[XasociaCasilla(SieteX_restri.adyacentes[saltos[0]][5]%7,SieteX_restri.adyacentes[saltos[0]][5]/7)].ocupado == true &&
				         	 											SieteX_restri.adyacentes[SieteX_restri.adyacentes[saltos[0]][5]][5] == numCasillaCandidata)
				         	 									{
				         	 										for (int a=15; a>0; a--)
				         	 										{
				         	 											if (saltos[a] != -1)
				         	 											{
				         	 												borrarCuadro(saltos[a]%7, saltos[a]/7);
				         	 											}
				         	 										}
				         	 										inicializaSaltos();
				         	 									}
				         	 									else 
				         	 										if (flagSalto == false)
				         	 										{
				         	 											inicializaSaltos();
				         	 										}
				         	 										flagSalto = true;
				         	 										numsalto++; //Aumentamos en uno el numero de salto
				         	 										saltos[numsalto] = numCasillaCandidata;
				         	 								}
			         	 				
				         	 								else
					         	 								if (SieteX_restri.adyacentes[saltos[0]][6] != -1 &&
					         	 										tablero.casillas[XasociaCasilla(SieteX_restri.adyacentes[saltos[0]][6]%7,SieteX_restri.adyacentes[saltos[0]][6]/7)].ocupado == true &&
					         	 										SieteX_restri.adyacentes[SieteX_restri.adyacentes[saltos[0]][6]][6] == numCasillaCandidata)
					         	 								{
					         	 									sal_borra[numsalto] = XasociaCasilla(SieteX_restri.adyacentes[saltos[numsalto]][6]%7,SieteX_restri.adyacentes[saltos[numsalto]][6]/7);
					         	 									flag = true;
					         	 									if (SieteX_restri.adyacentes[saltos[0]][6] != -1 &&
					         	 											tablero.casillas[XasociaCasilla(SieteX_restri.adyacentes[saltos[0]][6]%7,SieteX_restri.adyacentes[saltos[0]][6]/7)].ocupado == true &&
					         	 											SieteX_restri.adyacentes[SieteX_restri.adyacentes[saltos[0]][6]][6] == numCasillaCandidata)
					         	 									{
					         	 										for (int a=15; a>0; a--)
					         	 										{
					         	 											if (saltos[a] != -1)
					         	 											{
					         	 												borrarCuadro(saltos[a]%7, saltos[a]/7);
					         	 											}
					         	 										}
					         	 										inicializaSaltos();
					         	 									}
					         	 									else 
					         	 										if (flagSalto == false)
					         	 										{
					         	 											inicializaSaltos();
					         	 										}
					         	 										flagSalto = true;
					         	 										numsalto++; //Aumentamos en uno el numero de salto
					         	 										saltos[numsalto] = numCasillaCandidata;
					         	 								}
					         	 								else
						         	 								if (SieteX_restri.adyacentes[saltos[0]][7] != -1 &&
						         	 										tablero.casillas[XasociaCasilla(SieteX_restri.adyacentes[saltos[0]][7]%7,SieteX_restri.adyacentes[saltos[0]][7]/7)].ocupado == true &&
						         	 										SieteX_restri.adyacentes[SieteX_restri.adyacentes[saltos[0]][7]][7] == numCasillaCandidata)
						         	 								{
						         	 									sal_borra[numsalto] = XasociaCasilla(SieteX_restri.adyacentes[saltos[numsalto]][7]%7,SieteX_restri.adyacentes[saltos[numsalto]][7]/7);
						         	 									flag = true;
						         	 									if (SieteX_restri.adyacentes[saltos[0]][7] != -1 &&
						         	 											tablero.casillas[XasociaCasilla(SieteX_restri.adyacentes[saltos[0]][7]%7,SieteX_restri.adyacentes[saltos[0]][7]/7)].ocupado == true &&
						         	 											SieteX_restri.adyacentes[SieteX_restri.adyacentes[saltos[0]][7]][7] == numCasillaCandidata)
						         	 									{
						         	 										for (int a=15; a>0; a--)
						         	 										{
						         	 											if (saltos[a] != -1)
						         	 											{
						         	 												borrarCuadro(saltos[a]%7, saltos[a]/7);
						         	 											}
						         	 										}
						         	 										inicializaSaltos();
						         	 									}
						         	 									else 
						         	 										if (flagSalto == false)
						         	 										{
						         	 											inicializaSaltos();
						         	 										}
						         	 										flagSalto = true;
						         	 										numsalto++; //Aumentamos en uno el numero de salto
						         	 										saltos[numsalto] = numCasillaCandidata;
						         	 								}
			         	 				
			         	 	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
			         	 				
	             	 			
			         	 				}

			         	 			if (flagSalto && flag)
			         	 			{
			         	 				if (numsalto == 1) //Para borrar las selecciones cuando se pivota con casillaSeleccionada
			         	 				{
			         	 					//System.out.println(numsalto);
			         	 					borrarCuadro (candidata_posi, candidata_posj);
			         	 				}
			         	 				candidata_posi = i;
			         	 				candidata_posj = j;
			         	 				dibujaCandidata(i,j);
			         	 				dibujaSeleccion(saltos[0]%7, saltos[0]/7);
			         	 				//System.out.println("salto???");
			         	 			}
	         	 			
			         	 			if(flag)
			         	 			{
	                			//Entramos aqui si ya esta seleccionada la posicion a la que
	                			//queremos mover y se esta esperando otro click ahi
	                			
	             	 			               			
	             	 		//hay ya una casilla seleccionada y la tenemos que quitar
			         	 				if (candidata_posi != -1 && candidata_posj != -1)
			         	 				{
			         	 					borrarCuadro (candidata_posi, candidata_posj);
			         	 					
			         	 				}
	                			
			         	 				candidata_posi = i;
			         	 				candidata_posj = j;
			         	 				dibujaCandidata(i,j);
			         	 				dibujaSeleccion(saltos[0]%7, saltos[0]/7);
			         	 				//System.out.println("JAVIsdfgsdf");
			         	 			}
			         	 			else
			         	 			{
			         	 				//Si el flag no esta activo no se hace nada (no hay seleccion ninguna)
			         	 			}
			             	 	}	
	             	 	
			            	}
	            }}
	    	}
	    	
		
	    	else  //caso en el que hacemos doble click
	    	{
	    		if(mouseevent.getClickCount()==2)
	    		{
	    			//System.out.println("JAVI");
	    			Graphics2D graphics2d = (Graphics2D)getGraphics();
	    			int l = mouseevent.getX();
	    			int k = mouseevent.getY();
	    			//if(l <= 20 || l >= 660 || k <=50 || k >= 690)
	    			//if(l <= 200 || l >= 800 || k <=50 || k >= 690)
	    			if(l <= 200 + 84 || l >= 662 + 84 || k <=50 || k >= 512)    
	    			{
	    				break label0;
	    			}
	            
	    			//int i = Math.round((l-20) / 80);
	    			//int i = Math.round((l-200) / 60);
			           // int j = Math.round((k-50) / 60);
	    			int i=0,j=0; 
		            if (l>=200 + 84 && l<=254 + 84)
		            {
		            	if (k>=50 && k<=104)
		            	{
		            		i = 0; 
		            		j = 0;
		            	}
		            	else if (k>=118 && k<=172)
		            	{
		            		i = 0;
		            		j = 1;
		            	}
		            	else if (k>=186 && k<=240)
		            	{
		            		i = 0;
		            		j = 2;
		            	}
		            	else if (k>=254 && k<=308)
		            	{
		            		i = 0;
		            		j = 3;
		            	}
		            	else if (k>=322 && k<=376)
		            	{
		            		i = 0;
		            		j = 4;
		            	}
		            	else if (k>=390 && k<=444)
		            	{
		            		i = 0;
		            		j = 5;
		            	}
		            	else if (k>=458 && k<=512)
		            	{
		            		i = 0;
		            		j = 6;
		            	}
		            }
		            else if (l>=268 + 84 && l<=322 + 84)
		            {
		            	if (k>=50 && k<=104)
		            	{
		            		i = 1; 
		            		j = 0;
		            	}
		            	else if (k>=118 && k<=172)
		            	{
		            		i = 1;
		            		j = 1;
		            	}
		            	else if (k>=186 && k<=240)
		            	{
		            		i = 1;
		            		j = 2;
		            	}
		            	else if (k>=254 && k<=308)
		            	{
		            		i = 1;
		            		j = 3;
		            	}
		            	else if (k>=322 && k<=376)
		            	{
		            		i = 1;
		            		j = 4;
		            	}
		            	else if (k>=390 && k<=444)
		            	{
		            		i = 1;
		            		j = 5;
		            	}
		            	else if (k>=458 && k<=512)
		            	{
		            		i = 1;
		            		j = 6;
		            	}
		            }
		            else if (l>=336 + 84 && l<=390 + 84)
		            {
		            	if (k>=50 && k<=104)
		            	{
		            		i = 2; 
		            		j = 0;
		            	}
		            	else if (k>=118 && k<=172)
		            	{
		            		i = 2;
		            		j = 1;
		            	}
		            	else if (k>=186 && k<=240)
		            	{
		            		i = 2;
		            		j = 2;
		            	}
		            	else if (k>=254 && k<=308)
		            	{
		            		i = 2;
		            		j = 3;
		            	}
		            	else if (k>=322 && k<=376)
		            	{
		            		i = 2;
		            		j = 4;
		            	}
		            	else if (k>=390 && k<=444)
		            	{
		            		i = 2;
		            		j = 5;
		            	}
		            	else if (k>=458 && k<=512)
		            	{
		            		i = 2;
		            		j = 6;
		            	}
		            }
		            else if (l>=404 + 84 && l<=458 + 84)
		            {
		            	if (k>=50 && k<=104)
		            	{
		            		i = 3; 
		            		j = 0;
		            	}
		            	else if (k>=118 && k<=172)
		            	{
		            		i = 3;
		            		j = 1;
		            	}
		            	else if (k>=186 && k<=240)
		            	{
		            		i = 3;
		            		j = 2;
		            	}
		            	else if (k>=254 && k<=308)
		            	{
		            		i = 3;
		            		j = 3;
		            	}
		            	else if (k>=322 && k<=376)
		            	{
		            		i = 3;
		            		j = 4;
		            	}
		            	else if (k>=390 && k<=444)
		            	{
		            		i = 3;
		            		j = 5;
		            	}
		            	else if (k>=458 && k<=512)
		            	{
		            		i = 3;
		            		j = 6;
		            	}
		            }
		            else if (l>=472 + 84 && l<=526 + 84)
		            {
		            	if (k>=50 && k<=104)
		            	{
		            		i = 4; 
		            		j = 0;
		            	}
		            	else if (k>=118 && k<=172)
		            	{
		            		i = 4;
		            		j = 1;
		            	}
		            	else if (k>=186 && k<=240)
		            	{
		            		i = 4;
		            		j = 2;
		            	}
		            	else if (k>=254 && k<=308)
		            	{
		            		i = 4;
		            		j = 3;
		            	}
		            	else if (k>=322 && k<=376)
		            	{
		            		i = 4;
		            		j = 4;
		            	}
		            	else if (k>=390 && k<=444)
		            	{
		            		i = 4;
		            		j = 5;
		            	}
		            	else if (k>=458 && k<=512)
		            	{
		            		i = 4;
		            		j = 6;
		            	}
		            }
		            else if (l>=540 + 84 && l<=594 + 84)
		            {
		            	if (k>=50 && k<=104)
		            	{
		            		i = 5; 
		            		j = 0;
		            	}
		            	else if (k>=118 && k<=172)
		            	{
		            		i = 5;
		            		j = 1;
		            	}
		            	else if (k>=186 && k<=240)
		            	{
		            		i = 5;
		            		j = 2;
		            	}
		            	else if (k>=254 && k<=308)
		            	{
		            		i = 5;
		            		j = 3;
		            	}
		            	else if (k>=322 && k<=376)
		            	{
		            		i = 5;
		            		j = 4;
		            	}
		            	else if (k>=390 && k<=444)
		            	{
		            		i = 5;
		            		j = 5;
		            	}
		            	else if (k>=458 && k<=512)
		            	{
		            		i = 5;
		            		j = 6;
		            	}
		            }
		            else if (l>=608 + 84 && l<=662 + 84)
		            {
		            	if (k>=50 && k<=104)
		            	{
		            		i = 6; 
		            		j = 0;
		            	}
		            	else if (k>=118 && k<=172)
		            	{
		            		i = 6;
		            		j = 1;
		            	}
		            	else if (k>=186 && k<=240)
		            	{
		            		i = 6;
		            		j = 2;
		            	}
		            	else if (k>=254 && k<=308)
		            	{
		            		i = 6;
		            		j = 3;
		            	}
		            	else if (k>=322 && k<=376)
		            	{
		            		i = 6;
		            		j = 4;
		            	}
		            	else if (k>=390 && k<=444)
		            	{
		            		i = 6;
		            		j = 5;
		            	}
		            	else if (k>=458 && k<=512)
		            	{
		            		i = 6;
		            		j = 6;
		            	}
		            } 
	                        
	    			
	            //caso en el que no haya ninguna casilla seleccionada
	            if(seleccionada_posi == -1 && seleccionada_posj == -1)	
	            {
	            	break label0;
	            }
	            
	            //Habiendo una seleccionada, hacemos doble click en otra casilla
	    		if(seleccionada_posi != i || seleccionada_posj != j)
	            {
	    			borrarCuadro (candidata_posi, candidata_posj); // Para evitar que se quede una casilla candidata
	    							//dibujada cuando se hace un doble click incorrecto
	    			
	    			//actualizamos los indices de la casilla seleccionada
	    			candidata_posi = i;
	    			candidata_posj = j;
	    		
	    			if(flag)//se puede realizar el movimiento
	              	{
	    				if(!flagSalto)
	    				{
	    					for (int a=0; a<16; a++)
	                        {
	                        	if (saltos[a] != -1)
	                        	{
	                        		borrarCuadro(saltos[a]%7, saltos[a]/7);
	                        	}
	                        }
	    				}
	    				
	    				numCasillaSeleccionada = XasociaCasilla(seleccionada_posi, seleccionada_posj);
	    				numCasillaCandidata = XasociaCasilla(candidata_posi, candidata_posj);
	    				dibujaCandidata(i,j);
	    				numsalto = 0;
	    				if(flagSalto)
	                    {
	    					
	                    	for (int a=1; a<16; a++)
	                    	{
	                    		if (saltos[a-1] != -1 && saltos[a] != -1)
	                    		{
	                    			borrarCuadro(saltos[a-1]%7, saltos[a-1]/7);
	                    			parpadeo();
	                    			borrarCuadro(sal_borra[a-1]%7, sal_borra[a-1]/7);
	                    			pintarPieza(tablero.casillas[numCasillaSeleccionada].numjugador, saltos[a]/7, saltos[a]%7, true);
	                    			//borrarCuadro(sal_borra[a-1]%5, sal_borra[a-1]/5);
	                    			numsalto++;
	                    			
	                    			parpadeo(); //Relentiza el proceso de dibujar los saltos
	                    			
	                    		}
	                    	}
	                    }
	                  
	    				borrarCuadro(seleccionada_posi, seleccionada_posj);
	    				
	    				//casilla_borrar = asociaCasilla(sal_borra[0]%5, sal_borra[0]/5);
	    				
	    				for (int a=0; a<16; a++)
	    				{
	    					//System.out.print(asociaCasilla(sal_borra[a]%5,sal_borra[a]/5) + ", ");
	    					if (sal_borra[a] != -1)
	    						vector_aux [a] = XasociaCasilla(sal_borra[a]%7, sal_borra[a]/7);
	    				}
	    				/*
	    				for (int a=0; a<16; a++)
	    					if (sal_borra[a] != -1)
	    						borrarCuadro(sal_borra[a]%5, sal_borra[a]/5);
	                	*/
	    				pintarPieza(tablero.casillas[numCasillaSeleccionada].numjugador, candidata_posj, candidata_posi, true);
	    				
	
	///////////////////////////////////    				///////////////////////////////
	                    //mover(numCasillaSeleccionada, numCasillaCandidata, casilla_borrar);
	                    mover(numCasillaSeleccionada, numCasillaCandidata, vector_aux);
	                    for (int a = 0; a<16;a++){
	                    	vector_aux[a] = -1;
	                    	sal_borra[a] = -1;
	                    }
	     ////////////////////////////////////////////////                    /////////////////////////////
	                    if(compruebaGanador()!=0)
	                    {
	                    	detenerJuego = true;
	                    	muestraGanador();
	                    }
	                    
	                    seleccionada_posj = -1;
	                    seleccionada_posi = -1;	
	                    candidata_posi = -1;
	                    candidata_posj = -1;
	                    inicializaSaltos();
	                    saltos[0]= -1; //Desanclamos el numCasillaSeleccionada, ya se se mueve la ficha
	                    flagSalto =false;
	                    flag = false;
	                    numsalto = 0;
	                    if(tablero.jugadores[turno-1].esPC && !detenerJuego)
	            		{
	            			mover_pc();
	            		}
	                    
	                    break label0;
	              	}
	              	else //no se puede realizar el movimiento
	              	{
	              		lAviso.setText("¡ERROR! El movimiento es incorrecto, no se puede realizar");
	              		
	              		/////////////////////SONIDOOOOOOOOOOOOOOOOOOOOOOOOO
	              		//soni.playSound("Sonido/Error.wav");
	              		////////////////////////////////////////////////
	              	}          	  
	      
	    	  		}
	    		}
	   
	    	}
		
			}//FIN TIPOTABL == 6
		 	
		 	if (tipotabl == 3)
		 	{
		 		if(tablero.jugadores[turno-1].esPC && cuentaEmpezar==0)
			 	{
			 		cuentaEmpezar = 1;
		        	tiempo.start();
			 	}	 	
	    	
	    	//caso en el que hacemos un solo click
			 	if(mouseevent.getClickCount() == 1)
		    	{    		
		    		Graphics2D graphics2d = (Graphics2D)getGraphics();
		            int l = mouseevent.getX();
		            int k = mouseevent.getY();
		            
		            //if(l <= 20 || l >= 660 || k <=50 || k >= 690)
		            //if(l <= 200 || l >= 800 || k <=50 || k >= 690)
		            if(l <= 200 + 84 || l >= 662 + 84 || k <=50 || k >= 512)
		            	break label0;
	            
		            detenerJuego = false;
		            
		            if(compruebaGanador()!= 0)
		            {
		            	detenerJuego = true;
		            }
		            
		            if(tablero.jugadores[turno-1].esPC)
		            {
		            	mover_pc();
		            	
		            	if(detenerJuego)//Implica que se ha terminado la partida
		            	{
		            		muestraGanador();
		            	}
	                       	
		            }
		            
	///// MIRAR TODO ESTO LOS BUCLES Y TAL Y TAL ////////////////////////////////////
		            // No es PC, es jugador normal.
		            else
		            {
			            //Calcula la coordenada i,j del tablero (16x16) que se pincha
			            //int i = Math.round((l-20) / 80);
		            	//int i = Math.round((l-200) / 60);
				           // int j = Math.round((k-50) / 60);
		            	int i=8,j=8; 
			            if (l>=200 + 84 && l<=254 + 84)
			            {
			            	if (k>=50 && k<=104)
			            	{
			            		i = 0; 
			            		j = 0;
			            	}
			            	else if (k>=118 && k<=172)
			            	{
			            		i = 0;
			            		j = 1;
			            	}
			            	else if (k>=186 && k<=240)
			            	{
			            		i = 0;
			            		j = 2;
			            	}
			            	else if (k>=254 && k<=308)
			            	{
			            		i = 0;
			            		j = 3;
			            	}
			            	else if (k>=322 && k<=376)
			            	{
			            		i = 0;
			            		j = 4;
			            	}
			            	else if (k>=390 && k<=444)
			            	{
			            		i = 0;
			            		j = 5;
			            	}
			            	else if (k>=458 && k<=512)
			            	{
			            		i = 0;
			            		j = 6;
			            	}
			            }
			            else if (l>=268 + 84 && l<=322 + 84)
			            {
			            	if (k>=50 && k<=104)
			            	{
			            		i = 1; 
			            		j = 0;
			            	}
			            	else if (k>=118 && k<=172)
			            	{
			            		i = 1;
			            		j = 1;
			            	}
			            	else if (k>=186 && k<=240)
			            	{
			            		i = 1;
			            		j = 2;
			            	}
			            	else if (k>=254 && k<=308)
			            	{
			            		i = 1;
			            		j = 3;
			            	}
			            	else if (k>=322 && k<=376)
			            	{
			            		i = 1;
			            		j = 4;
			            	}
			            	else if (k>=390 && k<=444)
			            	{
			            		i = 1;
			            		j = 5;
			            	}
			            	else if (k>=458 && k<=512)
			            	{
			            		i = 1;
			            		j = 6;
			            	}
			            }
			            else if (l>=336 + 84 && l<=390 + 84)
			            {
			            	if (k>=50 && k<=104)
			            	{
			            		i = 2; 
			            		j = 0;
			            	}
			            	else if (k>=118 && k<=172)
			            	{
			            		i = 2;
			            		j = 1;
			            	}
			            	else if (k>=186 && k<=240)
			            	{
			            		i = 2;
			            		j = 2;
			            	}
			            	else if (k>=254 && k<=308)
			            	{
			            		i = 2;
			            		j = 3;
			            	}
			            	else if (k>=322 && k<=376)
			            	{
			            		i = 2;
			            		j = 4;
			            	}
			            	else if (k>=390 && k<=444)
			            	{
			            		i = 2;
			            		j = 5;
			            	}
			            	else if (k>=458 && k<=512)
			            	{
			            		i = 2;
			            		j = 6;
			            	}
			            }
			            else if (l>=404 + 84 && l<=458 + 84)
			            {
			            	if (k>=50 && k<=104)
			            	{
			            		i = 3; 
			            		j = 0;
			            	}
			            	else if (k>=118 && k<=172)
			            	{
			            		i = 3;
			            		j = 1;
			            	}
			            	else if (k>=186 && k<=240)
			            	{
			            		i = 3;
			            		j = 2;
			            	}
			            	else if (k>=254 && k<=308)
			            	{
			            		i = 3;
			            		j = 3;
			            	}
			            	else if (k>=322 && k<=376)
			            	{
			            		i = 3;
			            		j = 4;
			            	}
			            	else if (k>=390 && k<=444)
			            	{
			            		i = 3;
			            		j = 5;
			            	}
			            	else if (k>=458 && k<=512)
			            	{
			            		i = 3;
			            		j = 6;
			            	}
			            }
			            else if (l>=472 + 84 && l<=526 + 84)
			            {
			            	if (k>=50 && k<=104)
			            	{
			            		i = 4; 
			            		j = 0;
			            	}
			            	else if (k>=118 && k<=172)
			            	{
			            		i = 4;
			            		j = 1;
			            	}
			            	else if (k>=186 && k<=240)
			            	{
			            		i = 4;
			            		j = 2;
			            	}
			            	else if (k>=254 && k<=308)
			            	{
			            		i = 4;
			            		j = 3;
			            	}
			            	else if (k>=322 && k<=376)
			            	{
			            		i = 4;
			            		j = 4;
			            	}
			            	else if (k>=390 && k<=444)
			            	{
			            		i = 4;
			            		j = 5;
			            	}
			            	else if (k>=458 && k<=512)
			            	{
			            		i = 4;
			            		j = 6;
			            	}
			            }
			            else if (l>=540 + 84 && l<=594 + 84)
			            {
			            	if (k>=50 && k<=104)
			            	{
			            		i = 5; 
			            		j = 0;
			            	}
			            	else if (k>=118 && k<=172)
			            	{
			            		i = 5;
			            		j = 1;
			            	}
			            	else if (k>=186 && k<=240)
			            	{
			            		i = 5;
			            		j = 2;
			            	}
			            	else if (k>=254 && k<=308)
			            	{
			            		i = 5;
			            		j = 3;
			            	}
			            	else if (k>=322 && k<=376)
			            	{
			            		i = 5;
			            		j = 4;
			            	}
			            	else if (k>=390 && k<=444)
			            	{
			            		i = 5;
			            		j = 5;
			            	}
			            	else if (k>=458 && k<=512)
			            	{
			            		i = 5;
			            		j = 6;
			            	}
			            }
			            else if (l>=608 + 84 && l<=662 + 84)
			            {
			            	if (k>=50 && k<=104)
			            	{
			            		i = 6; 
			            		j = 0;
			            	}
			            	else if (k>=118 && k<=172)
			            	{
			            		i = 6;
			            		j = 1;
			            	}
			            	else if (k>=186 && k<=240)
			            	{
			            		i = 6;
			            		j = 2;
			            	}
			            	else if (k>=254 && k<=308)
			            	{
			            		i = 6;
			            		j = 3;
			            	}
			            	else if (k>=322 && k<=376)
			            	{
			            		i = 6;
			            		j = 4;
			            	}
			            	else if (k>=390 && k<=444)
			            	{
			            		i = 6;
			            		j = 5;
			            	}
			            	else if (k>=458 && k<=512)
			            	{
			            		i = 6;
			            		j = 6;
			            	}
			            } 
		                     
			          //Si deseleccionamos la casilla seleccionada
			            if(seleccionada_posi == i && seleccionada_posj == j)
			            {
			                if(flagSalto)
			                {
			                	for (int a=15; a>0; a--)
			                	{
			                		if (saltos[a] != -1)
			                		{
			                			borrarCuadro(saltos[a]%7, saltos[a]/7);
			                		}
			                	}
			                }
	            	
			            	borrarCuadro(i, j);
			                borrarCuadro (candidata_posi, candidata_posj);
			                pintarPieza(tablero.casillas[XasociaCasilla(i,j)].numjugador, j, i, true);
			              
			                seleccionada_posj = -1;
			                seleccionada_posi = -1;	
			                candidata_posi = -1;
			                candidata_posj = -1;
			                
			                inicializaSaltos();
			                
			                saltos[0]= -1;
			                sal_borra[0] = -1;
			                vector_aux[0]=-1;
			                
			                break label0;
			            }            
	            
			            //Cuando seleccionamos
			            if(seleccionada_posi == -1 && seleccionada_posj == -1)
			            {	
			            	if (i>7 && j >7)
			            	{
			            		break label0;
			            	}
			            	//Si pinchamos en una casilla sin ficha (sin que haya nada seleccionado)
			            	if (tablero.casillas[XasociaCasilla(i,j)].ocupado == false)
			                    break label0;
		            	
			            	//Si pinchamos para seleccionar en una ficha cuyo turno no corresponde
			            	if(tablero.casillas[XasociaCasilla(i,j)].numjugador != turno)
			            		break label0;
		            	
			                seleccionada_posi = i;
			                seleccionada_posj = j;
		                               
		                
			                //Para comenzar el tiempo la primera vez que pinchemos
			                if(cuentaEmpezar==0)
			                {	
			                	cuentaEmpezar = 1;
			                	tiempo.start();
			                }
			              
			                dibujaSeleccion(i, j);
			                
			                saltos[0] = XasociaCasilla(seleccionada_posi, seleccionada_posj); 
			                //System.out.println("buaahh " + saltos[0]);
			            }
			            
			            else //Caso en el que haya una ficha seleccionada y pincha en otra casilla 
			            {
			            	if(seleccionada_posi != i || seleccionada_posj != j)
			            	{   
			            		System.out.println(i + "-" + j);
			            		if (i>7 && j >7)
				            	{
				            		if(flagSalto)
					                {
					                	for (int a=15; a>0; a--)
					                	{
					                		if (saltos[a] != -1)
					                		{
					                			borrarCuadro(saltos[a]%7, saltos[a]/7);
					                		}
					                	}
					                }
			            	
					            	borrarCuadro(i, j);
					                borrarCuadro (candidata_posi, candidata_posj);
					                borrarCuadro (i, j);
					                pintarPieza(tablero.casillas[XasociaCasilla(seleccionada_posi,seleccionada_posj)].numjugador, seleccionada_posj, seleccionada_posi, true);
					                seleccionada_posj = -1;
					                seleccionada_posi = -1;	
					                inicializaSaltos();
					                saltos[0]= -1;
					                sal_borra[0] = -1;
					                vector_aux[0]=-1;
				            		break label0;
				            	}
			             	 	if(tablero.casillas[XasociaCasilla(i,j)].ocupado == false)
			             	 	{ 
	//Se activa cuando hay posibilidad de movimiento (espera un nuevo click a esa posicion para ejecutar el cambio)
	             	 	            flag = false;
			             	 	    numCasillaCandidata = XasociaCasilla(i, j);
			         	 			numCasillaSeleccionada = XasociaCasilla(seleccionada_posi, seleccionada_posj);
			         	 			if (saltos[0] == -1)
			         	 			{
			         	 				saltos[0] = numCasillaSeleccionada; //La casilla seleccionada de verdad
			         	 				System.out.println("la casilla d verdad " + saltos[0]);
			         	 			}
	         	 			
			         	 			if(tablero.casillas[numCasillaSeleccionada].numjugador == 1)
			         	 			{
			         	 				//Tratamos el movimiento simple (para el jugador 1 y para el jugador 3)
			         	 				
			         	 			////////////////////////////////////////////////
			         	 				//MIOOOOOOOOOOOOOOOOO
			         	 			//////////////////////////////////////////////////
			         	 				if (Cruz.adyacentes[numCasillaSeleccionada][0] == numCasillaCandidata)
			         	 				{
			         	 					for (int a=15; a>0; a--)
			         	 					{
			         	 						if (saltos[a] != -1)
			         	 						{
			         	 							borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 						}
			         	 					}
			                 	 			flag = true;
			                 	 			flagSalto = false;
			                 	 			inicializaSaltos();
			         	 				}
			         	 				else
			         	 					if (Cruz.adyacentes[numCasillaSeleccionada][1] == numCasillaCandidata)
				         	 				{
				         	 					for (int a=15; a>0; a--)
				         	 					{
				         	 						if (saltos[a] != -1)
				         	 						{
				         	 							borrarCuadro(saltos[a]%7, saltos[a]/7);
				         	 						}
				         	 					}
				                 	 			flag = true;
				                 	 			flagSalto = false;
				                 	 			inicializaSaltos();
				         	 				}
			         	 					else
			         	 						if (Cruz.adyacentes[numCasillaSeleccionada][2] == numCasillaCandidata)
					         	 				{
					         	 					for (int a=15; a>0; a--)
					         	 					{
					         	 						if (saltos[a] != -1)
					         	 						{
					         	 							borrarCuadro(saltos[a]%7, saltos[a]/7);
					         	 						}
					         	 					}
					                 	 			flag = true;
					                 	 			flagSalto = false;
					                 	 			inicializaSaltos();
					         	 				}
			         	 						else
			         	 				
			   //////////////////////////////////////////////////////////////////////////////////////////////
			         	 				
			         	 				
			         	 				
			         	 				if (Cruz.adyacentes[numCasillaSeleccionada][3] == numCasillaCandidata)
			         	 				{
			         	 					for (int a=15; a>0; a--)
			         	 					{
			         	 						if (saltos[a] != -1)
			         	 						{
			         	 							borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 						}
			         	 					}
			                 	 			flag = true;
			                 	 			flagSalto = false;
			                 	 			inicializaSaltos();
			         	 				}
			         	 				
			         	 				else 
			         	 					if (Cruz.adyacentes[numCasillaSeleccionada][4] == numCasillaCandidata)
			         	 					{
			         	 						for (int a=15; a>0; a--)
			         	 						{
			         	 							if (saltos[a] != -1)
			         	 							{
			         	 								borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 							}
			         	 						}
			         	 						flag = true;
			         	 						flagSalto = false;
			         	 						inicializaSaltos();
			         	 					}
			         	 					else 
			         	 						if (Cruz.adyacentes[numCasillaSeleccionada][5] == numCasillaCandidata)
			         	 						{
			         	 							for (int a=15; a>0; a--)
			         	 							{
			         	 								if (saltos[a] != -1)
			         	 								{
			         	 									borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 								}
			         	 							}
			         	 							flag = true;
			         	 							flagSalto = false;
			         	 							inicializaSaltos();
			         	 						}
			         	 						else 
			         	 							if (Cruz.adyacentes[numCasillaSeleccionada][6] == numCasillaCandidata)
			         	 							{
			         	 								for (int a=15; a>0; a--)
			         	 								{
			         	 									if (saltos[a] != -1)
			         	 									{
			         	 										borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 									}
			         	 								}
			         	 								flag = true;
			         	 								flagSalto = false;
			         	 								inicializaSaltos();
			         	 							}
			         	 							else 
			         	 								if (Cruz.adyacentes[numCasillaSeleccionada][7] == numCasillaCandidata)
			         	 								{
			         	 									for (int a=15; a>0; a--)
			         	 									{
			         	 										if (saltos[a] != -1)
			         	 										{
			         	 											borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 										}
			         	 									}
			         	 									flag = true;
			         	 									flagSalto = false;
			         	 									inicializaSaltos();
			         	 								}
	             	 			
			         	 			}
	          	 		
			         	 			else 
			         	 				if(tablero.casillas[numCasillaSeleccionada].numjugador == 2)
			         	 						//|| tablero.casillas[numCasillaSeleccionada].numjugador == 4)
			         	 				{
	             	 			//Tratamos el movimiento simple (para el jugador 2 y para el jugador 4)
	             	 			
			         	 					if (Cruz.adyacentes[numCasillaSeleccionada][0] == numCasillaCandidata)
			         	 					{
			         	 						for (int a=15; a>0; a--)
			         	 						{
			         	 							if (saltos[a] != -1)
			         	 							{
			         	 								borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 							}
			         	 						}
			         	 						flag = true;
			         	 						flagSalto = false;
			         	 						inicializaSaltos();
			         	 					}
			         	 					else 
			         	 						if (Cruz.adyacentes[numCasillaSeleccionada][1] == numCasillaCandidata)
			         	 						{
			         	 							for (int a=15; a>0; a--)
			         	 							{
			         	 								if (saltos[a] != -1)
			         	 								{
			         	 									borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 								}
			         	 							}
			         	 							flag = true;
			         	 							flagSalto = false;
			         	 							inicializaSaltos();
			         	 						}
			         	 						else 
			         	 							if (Cruz.adyacentes[numCasillaSeleccionada][2] == numCasillaCandidata)
			         	 							{
			         	 								for (int a=15; a>0; a--)
			         	 								{
			         	 									if (saltos[a] != -1)
			         	 									{
			         	 										borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 									}
			         	 								}
			         	 								flag = true;
			         	 								flagSalto = false;
			         	 								inicializaSaltos();
			         	 							}
			         	 							else 
			         	 								if (Cruz.adyacentes[numCasillaSeleccionada][3] == numCasillaCandidata)
			         	 								{
			         	 									for (int a=15; a>0; a--)
			         	 									{
			         	 										if (saltos[a] != -1)
			         	 										{
			         	 											borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 										}
			         	 									}
			         	 									flag = true;
			         	 									flagSalto = false;
			         	 									inicializaSaltos();
			         	 								}
			         	 								else 
			         	 									if (Cruz.adyacentes[numCasillaSeleccionada][4] == numCasillaCandidata)
			         	 									{
			         	 										for (int a=15; a>0; a--)
			         	 										{
			         	 											if (saltos[a] != -1)
			         	 											{
			         	 												borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 											}
			         	 										}
			         	 										flag = true;
			         	 										flagSalto = false;
			         	 										inicializaSaltos();
			         	 									}
			         	 					
			         	 ////////////////////////////////////////////////////////////////////////////////
			         	 					//MIOOOOOOOOOOOOOOOOOOOOOOOO
			         	 ////////////////////////////////////////////////////////////////////////////////					
	             	 			
			         	 									else 
				         	 									if (Cruz.adyacentes[numCasillaSeleccionada][5] == numCasillaCandidata)
				         	 									{
				         	 										for (int a=15; a>0; a--)
				         	 										{
				         	 											if (saltos[a] != -1)
				         	 											{
				         	 												borrarCuadro(saltos[a]%7, saltos[a]/7);
				         	 											}
				         	 										}
				         	 										flag = true;
				         	 										flagSalto = false;
				         	 										inicializaSaltos();
				         	 									}
				         	 									else 
					         	 									if (Cruz.adyacentes[numCasillaSeleccionada][6] == numCasillaCandidata)
					         	 									{
					         	 										for (int a=15; a>0; a--)
					         	 										{
					         	 											if (saltos[a] != -1)
					         	 											{
					         	 												borrarCuadro(saltos[a]%7, saltos[a]/7);
					         	 											}
					         	 										}
					         	 										flag = true;
					         	 										flagSalto = false;
					         	 										inicializaSaltos();
					         	 									}
					         	 									else 
						         	 									if (Cruz.adyacentes[numCasillaSeleccionada][7] == numCasillaCandidata)
						         	 									{
						         	 										for (int a=15; a>0; a--)
						         	 										{
						         	 											if (saltos[a] != -1)
						         	 											{
						         	 												borrarCuadro(saltos[a]%7, saltos[a]/7);
						         	 											}
						         	 										}
						         	 										flag = true;
						         	 										flagSalto = false;
						         	 										inicializaSaltos();
						         	 									}
			         	 	////////////////////////////////////////////////////////////////////////////////////////////////////////////				
			         	 					
			         	 					//Tratamos la situacion de un salto (para el jugador 2 y para el jugador 4)
	             	 			
			         	 				if (Cruz.adyacentes[saltos[0]][0] != -1 &&
			         	 						tablero.casillas[XasociaCasilla(Cruz.adyacentes[saltos[0]][0]%7,Cruz.adyacentes[saltos[0]][0]/7)].ocupado == true &&
			         	 						Cruz.adyacentes[Cruz.adyacentes[saltos[0]][0]][0] == numCasillaCandidata)
			         	 				{
			         	 					sal_borra[numsalto] = XasociaCasilla(Cruz.adyacentes[saltos[numsalto]][0]%7,Cruz.adyacentes[saltos[numsalto]][0]/7);
			         	 					flag = true;
			         	 					if (Cruz.adyacentes[saltos[0]][0] != -1 &&
			         	 						tablero.casillas[XasociaCasilla(Cruz.adyacentes[saltos[0]][0]%7,Cruz.adyacentes[saltos[0]][0]/7)].ocupado == true &&
			         	 						Cruz.adyacentes[Cruz.adyacentes[saltos[0]][0]][0] == numCasillaCandidata)
			         	 					{
			         	 						for (int a=15; a>0; a--)
			         	 						{
			         	 							if (saltos[a] != -1)
			         	 							{
			         	 								borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 							}
			         	 						}
			         	 						inicializaSaltos();
			         	 					}
			         	 					else
			         	 						if (flagSalto == false)
			         	 						{
			         	 							inicializaSaltos();
			         	 						}
			         	 						flagSalto = true;
			         	 						numsalto++; //Aumentamos en uno el numero de salto
			         	 						saltos[numsalto] = numCasillaCandidata;
			         	 				}
			         	 				else 
			         	 					if (Cruz.adyacentes[saltos[0]][1] != -1 &&
			         	 							tablero.casillas[XasociaCasilla(Cruz.adyacentes[saltos[0]][1]%7,Cruz.adyacentes[saltos[0]][1]/7)].ocupado == true &&
			         	 							Cruz.adyacentes[Cruz.adyacentes[saltos[0]][1]][1] == numCasillaCandidata)
			         	 					{
			         	 						sal_borra[numsalto] = XasociaCasilla(Cruz.adyacentes[saltos[numsalto]][1]%7,Cruz.adyacentes[saltos[numsalto]][1]/7);
			         	 						flag = true;
			         	 						if (Cruz.adyacentes[saltos[0]][1] != -1 &&
			         	 								tablero.casillas[XasociaCasilla(Cruz.adyacentes[saltos[0]][1]%7,Cruz.adyacentes[saltos[0]][1]/7)].ocupado == true &&
			         	 								Cruz.adyacentes[Cruz.adyacentes[saltos[0]][1]][1] == numCasillaCandidata)
			         	 						{
			         	 							for (int a=15; a>0; a--)
			         	 							{
			         	 								if (saltos[a] != -1)
			         	 								{
			         	 									borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 								}
			         	 							}
			         	 							inicializaSaltos();
			         	 						}
			         	 						else 
			         	 							if (flagSalto == false)
			         	 							{
			         	 								inicializaSaltos();
			         	 							}
			         	 							flagSalto = true;
			         	 							numsalto++; //Aumentamos en uno el numero de salto
			         	 							saltos[numsalto] = numCasillaCandidata;
			         	 					}
			         	 					else 
			         	 						if (Cruz.adyacentes[saltos[0]][2] != -1 &&
			         	 								tablero.casillas[XasociaCasilla(Cruz.adyacentes[saltos[0]][2]%7,Cruz.adyacentes[saltos[0]][2]/7)].ocupado == true &&
			         	 								Cruz.adyacentes[Cruz.adyacentes[saltos[0]][2]][2] == numCasillaCandidata)
			         	 						{
			         	 							sal_borra[numsalto] = XasociaCasilla(Cruz.adyacentes[saltos[numsalto]][2]%7,Cruz.adyacentes[saltos[numsalto]][2]/7);
			         	 							flag = true;
			         	 							if (Cruz.adyacentes[saltos[0]][2] != -1 &&
			         	 									tablero.casillas[XasociaCasilla(Cruz.adyacentes[saltos[0]][2]%7,Cruz.adyacentes[saltos[0]][2]/7)].ocupado == true &&
			         	 									Cruz.adyacentes[Cruz.adyacentes[saltos[0]][2]][2] == numCasillaCandidata)
			         	 							{
			         	 								for (int a=15; a>0; a--)
			         	 								{
			         	 									if (saltos[a] != -1)
			         	 									{
			         	 										borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 									}
			         	 								}
			         	 								inicializaSaltos();
			         	 							}
			         	 							else 
			         	 								if (flagSalto == false)
			         	 								{
			         	 									inicializaSaltos();
			         	 								}
			         	 								flagSalto = true;
			         	 								numsalto++; //Aumentamos en uno el numero de salto
			         	 								saltos[numsalto] = numCasillaCandidata;
			         	 						}
			         	 						else 
			         	 							if (Cruz.adyacentes[saltos[0]][3] != -1 &&
			         	 									tablero.casillas[XasociaCasilla(Cruz.adyacentes[saltos[0]][3]%7,Cruz.adyacentes[saltos[0]][3]/7)].ocupado == true &&
			         	 									Cruz.adyacentes[Cruz.adyacentes[saltos[0]][3]][3] == numCasillaCandidata)
			         	 							{
			         	 								System.out.println("Saltos 0 vale " + saltos[0]);
			         	 								System.out.println("Saltos numsalto vale " + saltos[numsalto]);
			         	 								System.out.println("el %16 vale " + Cruz.adyacentes[saltos[numsalto]][3]%7 + " y el /16 vale " + SieteX.adyacentes[saltos[numsalto]][3]/7);
			         	 								
			         	 								sal_borra[numsalto] = XasociaCasilla(Cruz.adyacentes[saltos[numsalto]][3]%7,Cruz.adyacentes[saltos[numsalto]][3]/7);
			         	 								System.out.println("El valor de sal_borra[0] es " + sal_borra[0]);
			         	 								System.out.println("num salto vale " + numsalto);
			         	 								flag = true;
			         	 								if (Cruz.adyacentes[saltos[0]][3] != -1 &&
			         	 										tablero.casillas[XasociaCasilla(Cruz.adyacentes[saltos[0]][3]%7,Cruz.adyacentes[saltos[0]][3]/7)].ocupado == true &&
			         	 										Cruz.adyacentes[Cruz.adyacentes[saltos[0]][3]][3] == numCasillaCandidata)
			         	 								{
			         	 									for (int a=15; a>0; a--)
			         	 									{
			         	 										if (saltos[a] != -1)
			         	 										{
			         	 											borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 										}
			         	 			        				}
			         	 									inicializaSaltos();
			         	 								}
			         	 								else 
			         	 									if (flagSalto == false)
			         	 									{
			         	 										inicializaSaltos();
			         	 									}
			         	 									flagSalto = true;
			         	 									numsalto++; //Aumentamos en uno el numero de salto
			         	 									saltos[numsalto] = numCasillaCandidata;
			         	 							}
			         	 							else
			         	 								if (Cruz.adyacentes[saltos[0]][4] != -1 &&
			         	 										tablero.casillas[XasociaCasilla(Cruz.adyacentes[saltos[0]][4]%7,Cruz.adyacentes[saltos[0]][4]/7)].ocupado == true &&
			         	 										Cruz.adyacentes[Cruz.adyacentes[saltos[0]][4]][4] == numCasillaCandidata)
			         	 								{
			         	 									sal_borra[numsalto] = XasociaCasilla(Cruz.adyacentes[saltos[numsalto]][4]%7,Cruz.adyacentes[saltos[numsalto]][4]/7);
			         	 									flag = true;
			         	 									if (Cruz.adyacentes[saltos[0]][4] != -1 &&
			         	 											tablero.casillas[XasociaCasilla(Cruz.adyacentes[saltos[0]][4]%7,Cruz.adyacentes[saltos[0]][4]/7)].ocupado == true &&
			         	 											Cruz.adyacentes[Cruz.adyacentes[saltos[0]][4]][4] == numCasillaCandidata)
			         	 									{
			         	 										for (int a=15; a>0; a--)
			         	 										{
			         	 											if (saltos[a] != -1)
			         	 											{
			         	 												borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 											}
			         	 										}
			         	 										inicializaSaltos();
			         	 									}
			         	 									else 
			         	 										if (flagSalto == false)
			         	 										{
			         	 											inicializaSaltos();
			         	 										}
			         	 										flagSalto = true;
			         	 										numsalto++; //Aumentamos en uno el numero de salto
			         	 										saltos[numsalto] = numCasillaCandidata;
			         	 								}
			         	 				
			       ////////////////////////////////////////////////////////////////////////////
			         	 				//MIO
			       /////////////////////////////////////////////////////////////////////////////
			         	 				
			         	 								else
				         	 								if (Cruz.adyacentes[saltos[0]][5] != -1 &&
				         	 										tablero.casillas[XasociaCasilla(Cruz.adyacentes[saltos[0]][5]%7,Cruz.adyacentes[saltos[0]][5]/7)].ocupado == true &&
				         	 										Cruz.adyacentes[Cruz.adyacentes[saltos[0]][5]][5] == numCasillaCandidata)
				         	 								{
				         	 									sal_borra[numsalto] = XasociaCasilla(Cruz.adyacentes[saltos[numsalto]][5]%7,Cruz.adyacentes[saltos[numsalto]][5]/7);
				         	 									flag = true;
				         	 									if (Cruz.adyacentes[saltos[0]][5] != -1 &&
				         	 											tablero.casillas[XasociaCasilla(Cruz.adyacentes[saltos[0]][5]%7,Cruz.adyacentes[saltos[0]][5]/7)].ocupado == true &&
				         	 											Cruz.adyacentes[Cruz.adyacentes[saltos[0]][5]][5] == numCasillaCandidata)
				         	 									{
				         	 										for (int a=15; a>0; a--)
				         	 										{
				         	 											if (saltos[a] != -1)
				         	 											{
				         	 												borrarCuadro(saltos[a]%7, saltos[a]/7);
				         	 											}
				         	 										}
				         	 										inicializaSaltos();
				         	 									}
				         	 									else 
				         	 										if (flagSalto == false)
				         	 										{
				         	 											inicializaSaltos();
				         	 										}
				         	 										flagSalto = true;
				         	 										numsalto++; //Aumentamos en uno el numero de salto
				         	 										saltos[numsalto] = numCasillaCandidata;
				         	 								}
			         	 				
				         	 								else
					         	 								if (Cruz.adyacentes[saltos[0]][6] != -1 &&
					         	 										tablero.casillas[XasociaCasilla(Cruz.adyacentes[saltos[0]][6]%7,Cruz.adyacentes[saltos[0]][6]/7)].ocupado == true &&
					         	 										Cruz.adyacentes[Cruz.adyacentes[saltos[0]][6]][6] == numCasillaCandidata)
					         	 								{
					         	 									sal_borra[numsalto] = XasociaCasilla(Cruz.adyacentes[saltos[numsalto]][6]%7,Cruz.adyacentes[saltos[numsalto]][6]/7);
					         	 									flag = true;
					         	 									if (Cruz.adyacentes[saltos[0]][6] != -1 &&
					         	 											tablero.casillas[XasociaCasilla(Cruz.adyacentes[saltos[0]][6]%7,Cruz.adyacentes[saltos[0]][6]/7)].ocupado == true &&
					         	 											Cruz.adyacentes[Cruz.adyacentes[saltos[0]][6]][6] == numCasillaCandidata)
					         	 									{
					         	 										for (int a=15; a>0; a--)
					         	 										{
					         	 											if (saltos[a] != -1)
					         	 											{
					         	 												borrarCuadro(saltos[a]%7, saltos[a]/7);
					         	 											}
					         	 										}
					         	 										inicializaSaltos();
					         	 									}
					         	 									else 
					         	 										if (flagSalto == false)
					         	 										{
					         	 											inicializaSaltos();
					         	 										}
					         	 										flagSalto = true;
					         	 										numsalto++; //Aumentamos en uno el numero de salto
					         	 										saltos[numsalto] = numCasillaCandidata;
					         	 								}
					         	 								else
						         	 								if (Cruz.adyacentes[saltos[0]][7] != -1 &&
						         	 										tablero.casillas[XasociaCasilla(Cruz.adyacentes[saltos[0]][7]%7,Cruz.adyacentes[saltos[0]][7]/7)].ocupado == true &&
						         	 										Cruz.adyacentes[Cruz.adyacentes[saltos[0]][7]][7] == numCasillaCandidata)
						         	 								{
						         	 									sal_borra[numsalto] = XasociaCasilla(Cruz.adyacentes[saltos[numsalto]][7]%7,Cruz.adyacentes[saltos[numsalto]][7]/7);
						         	 									flag = true;
						         	 									if (Cruz.adyacentes[saltos[0]][7] != -1 &&
						         	 											tablero.casillas[XasociaCasilla(Cruz.adyacentes[saltos[0]][7]%7,Cruz.adyacentes[saltos[0]][7]/7)].ocupado == true &&
						         	 											Cruz.adyacentes[Cruz.adyacentes[saltos[0]][7]][7] == numCasillaCandidata)
						         	 									{
						         	 										for (int a=15; a>0; a--)
						         	 										{
						         	 											if (saltos[a] != -1)
						         	 											{
						         	 												borrarCuadro(saltos[a]%7, saltos[a]/7);
						         	 											}
						         	 										}
						         	 										inicializaSaltos();
						         	 									}
						         	 									else 
						         	 										if (flagSalto == false)
						         	 										{
						         	 											inicializaSaltos();
						         	 										}
						         	 										flagSalto = true;
						         	 										numsalto++; //Aumentamos en uno el numero de salto
						         	 										saltos[numsalto] = numCasillaCandidata;
						         	 								}
			         	 				
			         	 	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
			         	 				
	             	 			
			         	 				}

			         	 			if (flagSalto && flag)
			         	 			{
			         	 				if (numsalto == 1) //Para borrar las selecciones cuando se pivota con casillaSeleccionada
			         	 				{
			         	 					//System.out.println(numsalto);
			         	 					borrarCuadro (candidata_posi, candidata_posj);
			         	 				}
			         	 				candidata_posi = i;
			         	 				candidata_posj = j;
			         	 				dibujaCandidata(i,j);
			         	 				dibujaSeleccion(saltos[0]%7, saltos[0]/7);
			         	 				//System.out.println("salto???");
			         	 			}
	         	 			
			         	 			if(flag)
			         	 			{
	                			//Entramos aqui si ya esta seleccionada la posicion a la que
	                			//queremos mover y se esta esperando otro click ahi
	                			
	             	 			               			
	             	 		//hay ya una casilla seleccionada y la tenemos que quitar
			         	 				if (candidata_posi != -1 && candidata_posj != -1)
			         	 				{
			         	 					borrarCuadro (candidata_posi, candidata_posj);
			         	 					
			         	 				}
	                			
			         	 				candidata_posi = i;
			         	 				candidata_posj = j;
			         	 				dibujaCandidata(i,j);
			         	 				dibujaSeleccion(saltos[0]%7, saltos[0]/7);
			         	 				//System.out.println("JAVIsdfgsdf");
			         	 			}
			         	 			else
			         	 			{
			         	 				//Si el flag no esta activo no se hace nada (no hay seleccion ninguna)
			         	 			}
			             	 	}	
	             	 	
			            	}
	            }}
	    	}
	    	
		
	    	else  //caso en el que hacemos doble click
	    	{
	    		if(mouseevent.getClickCount()==2)
	    		{
	    			//System.out.println("JAVI");
	    			Graphics2D graphics2d = (Graphics2D)getGraphics();
	    			int l = mouseevent.getX();
	    			int k = mouseevent.getY();
	    			//if(l <= 20 || l >= 660 || k <=50 || k >= 690)
	    			//if(l <= 200 || l >= 800 || k <=50 || k >= 690)
	    			if(l <= 200 + 84 || l >= 662 + 84 || k <=50 || k >= 512)    
	    			{
	    				break label0;
	    			}
	            
	    			//int i = Math.round((l-20) / 80);
	    			//int i = Math.round((l-200) / 60);
			           // int j = Math.round((k-50) / 60);
	    			int i=0,j=0; 
		            if (l>=200 + 84 && l<=254 + 84)
		            {
		            	if (k>=50 && k<=104)
		            	{
		            		i = 0; 
		            		j = 0;
		            	}
		            	else if (k>=118 && k<=172)
		            	{
		            		i = 0;
		            		j = 1;
		            	}
		            	else if (k>=186 && k<=240)
		            	{
		            		i = 0;
		            		j = 2;
		            	}
		            	else if (k>=254 && k<=308)
		            	{
		            		i = 0;
		            		j = 3;
		            	}
		            	else if (k>=322 && k<=376)
		            	{
		            		i = 0;
		            		j = 4;
		            	}
		            	else if (k>=390 && k<=444)
		            	{
		            		i = 0;
		            		j = 5;
		            	}
		            	else if (k>=458 && k<=512)
		            	{
		            		i = 0;
		            		j = 6;
		            	}
		            }
		            else if (l>=268 + 84 && l<=322 + 84)
		            {
		            	if (k>=50 && k<=104)
		            	{
		            		i = 1; 
		            		j = 0;
		            	}
		            	else if (k>=118 && k<=172)
		            	{
		            		i = 1;
		            		j = 1;
		            	}
		            	else if (k>=186 && k<=240)
		            	{
		            		i = 1;
		            		j = 2;
		            	}
		            	else if (k>=254 && k<=308)
		            	{
		            		i = 1;
		            		j = 3;
		            	}
		            	else if (k>=322 && k<=376)
		            	{
		            		i = 1;
		            		j = 4;
		            	}
		            	else if (k>=390 && k<=444)
		            	{
		            		i = 1;
		            		j = 5;
		            	}
		            	else if (k>=458 && k<=512)
		            	{
		            		i = 1;
		            		j = 6;
		            	}
		            }
		            else if (l>=336 + 84 && l<=390 + 84)
		            {
		            	if (k>=50 && k<=104)
		            	{
		            		i = 2; 
		            		j = 0;
		            	}
		            	else if (k>=118 && k<=172)
		            	{
		            		i = 2;
		            		j = 1;
		            	}
		            	else if (k>=186 && k<=240)
		            	{
		            		i = 2;
		            		j = 2;
		            	}
		            	else if (k>=254 && k<=308)
		            	{
		            		i = 2;
		            		j = 3;
		            	}
		            	else if (k>=322 && k<=376)
		            	{
		            		i = 2;
		            		j = 4;
		            	}
		            	else if (k>=390 && k<=444)
		            	{
		            		i = 2;
		            		j = 5;
		            	}
		            	else if (k>=458 && k<=512)
		            	{
		            		i = 2;
		            		j = 6;
		            	}
		            }
		            else if (l>=404 + 84 && l<=458 + 84)
		            {
		            	if (k>=50 && k<=104)
		            	{
		            		i = 3; 
		            		j = 0;
		            	}
		            	else if (k>=118 && k<=172)
		            	{
		            		i = 3;
		            		j = 1;
		            	}
		            	else if (k>=186 && k<=240)
		            	{
		            		i = 3;
		            		j = 2;
		            	}
		            	else if (k>=254 && k<=308)
		            	{
		            		i = 3;
		            		j = 3;
		            	}
		            	else if (k>=322 && k<=376)
		            	{
		            		i = 3;
		            		j = 4;
		            	}
		            	else if (k>=390 && k<=444)
		            	{
		            		i = 3;
		            		j = 5;
		            	}
		            	else if (k>=458 && k<=512)
		            	{
		            		i = 3;
		            		j = 6;
		            	}
		            }
		            else if (l>=472 + 84 && l<=526 + 84)
		            {
		            	if (k>=50 && k<=104)
		            	{
		            		i = 4; 
		            		j = 0;
		            	}
		            	else if (k>=118 && k<=172)
		            	{
		            		i = 4;
		            		j = 1;
		            	}
		            	else if (k>=186 && k<=240)
		            	{
		            		i = 4;
		            		j = 2;
		            	}
		            	else if (k>=254 && k<=308)
		            	{
		            		i = 4;
		            		j = 3;
		            	}
		            	else if (k>=322 && k<=376)
		            	{
		            		i = 4;
		            		j = 4;
		            	}
		            	else if (k>=390 && k<=444)
		            	{
		            		i = 4;
		            		j = 5;
		            	}
		            	else if (k>=458 && k<=512)
		            	{
		            		i = 4;
		            		j = 6;
		            	}
		            }
		            else if (l>=540 + 84 && l<=594 + 84)
		            {
		            	if (k>=50 && k<=104)
		            	{
		            		i = 5; 
		            		j = 0;
		            	}
		            	else if (k>=118 && k<=172)
		            	{
		            		i = 5;
		            		j = 1;
		            	}
		            	else if (k>=186 && k<=240)
		            	{
		            		i = 5;
		            		j = 2;
		            	}
		            	else if (k>=254 && k<=308)
		            	{
		            		i = 5;
		            		j = 3;
		            	}
		            	else if (k>=322 && k<=376)
		            	{
		            		i = 5;
		            		j = 4;
		            	}
		            	else if (k>=390 && k<=444)
		            	{
		            		i = 5;
		            		j = 5;
		            	}
		            	else if (k>=458 && k<=512)
		            	{
		            		i = 5;
		            		j = 6;
		            	}
		            }
		            else if (l>=608 + 84 && l<=662 + 84)
		            {
		            	if (k>=50 && k<=104)
		            	{
		            		i = 6; 
		            		j = 0;
		            	}
		            	else if (k>=118 && k<=172)
		            	{
		            		i = 6;
		            		j = 1;
		            	}
		            	else if (k>=186 && k<=240)
		            	{
		            		i = 6;
		            		j = 2;
		            	}
		            	else if (k>=254 && k<=308)
		            	{
		            		i = 6;
		            		j = 3;
		            	}
		            	else if (k>=322 && k<=376)
		            	{
		            		i = 6;
		            		j = 4;
		            	}
		            	else if (k>=390 && k<=444)
		            	{
		            		i = 6;
		            		j = 5;
		            	}
		            	else if (k>=458 && k<=512)
		            	{
		            		i = 6;
		            		j = 6;
		            	}
		            } 
	                        
	    			
	            //caso en el que no haya ninguna casilla seleccionada
	            if(seleccionada_posi == -1 && seleccionada_posj == -1)	
	            {
	            	break label0;
	            }
	            
	            //Habiendo una seleccionada, hacemos doble click en otra casilla
	    		if(seleccionada_posi != i || seleccionada_posj != j)
	            {
            		
	    			borrarCuadro (candidata_posi, candidata_posj); // Para evitar que se quede una casilla candidata
	    							//dibujada cuando se hace un doble click incorrecto
	    			
	    			//actualizamos los indices de la casilla seleccionada
	    			candidata_posi = i;
	    			candidata_posj = j;
	    		
	    			if(flag)//se puede realizar el movimiento
	              	{
	    				if(!flagSalto)
	    				{
	    					for (int a=0; a<16; a++)
	                        {
	                        	if (saltos[a] != -1)
	                        	{
	                        		borrarCuadro(saltos[a]%7, saltos[a]/7);
	                        	}
	                        }
	    				}
	    				
	    				numCasillaSeleccionada = XasociaCasilla(seleccionada_posi, seleccionada_posj);
	    				numCasillaCandidata = XasociaCasilla(candidata_posi, candidata_posj);
	    				dibujaCandidata(i,j);
	    				numsalto = 0;
	    				if(flagSalto)
	                    {
	    					
	                    	for (int a=1; a<16; a++)
	                    	{
	                    		if (saltos[a-1] != -1 && saltos[a] != -1)
	                    		{
	                    			borrarCuadro(saltos[a-1]%7, saltos[a-1]/7);
	                    			parpadeo();
	                    			borrarCuadro(sal_borra[a-1]%7, sal_borra[a-1]/7);
	                    			pintarPieza(tablero.casillas[numCasillaSeleccionada].numjugador, saltos[a]/7, saltos[a]%7, true);
	                    			//borrarCuadro(sal_borra[a-1]%5, sal_borra[a-1]/5);
	                    			numsalto++;
	                    			
	                    			parpadeo(); //Relentiza el proceso de dibujar los saltos
	                    			
	                    		}
	                    	}
	                    }
	                  
	    				borrarCuadro(seleccionada_posi, seleccionada_posj);
	    				
	    				//casilla_borrar = asociaCasilla(sal_borra[0]%5, sal_borra[0]/5);
	    				
	    				for (int a=0; a<16; a++)
	    				{
	    					//System.out.print(asociaCasilla(sal_borra[a]%5,sal_borra[a]/5) + ", ");
	    					if (sal_borra[a] != -1)
	    						vector_aux [a] = XasociaCasilla(sal_borra[a]%7, sal_borra[a]/7);
	    				}
	    				/*
	    				for (int a=0; a<16; a++)
	    					if (sal_borra[a] != -1)
	    						borrarCuadro(sal_borra[a]%5, sal_borra[a]/5);
	                	*/
	    				pintarPieza(tablero.casillas[numCasillaSeleccionada].numjugador, candidata_posj, candidata_posi, true);
	    				
	
	///////////////////////////////////    				///////////////////////////////
	                    //mover(numCasillaSeleccionada, numCasillaCandidata, casilla_borrar);
	                    mover(numCasillaSeleccionada, numCasillaCandidata, vector_aux);
	                    for (int a = 0; a<16;a++){
	                    	vector_aux[a] = -1;
	                    	sal_borra[a] = -1;
	                    }
	     ////////////////////////////////////////////////                    /////////////////////////////
	                    if(compruebaGanador()!=0)
	                    {
	                    	detenerJuego = true;
	                    	muestraGanador();
	                    }
	                    
	                    seleccionada_posj = -1;
	                    seleccionada_posi = -1;	
	                    candidata_posi = -1;
	                    candidata_posj = -1;
	                    inicializaSaltos();
	                    saltos[0]= -1; //Desanclamos el numCasillaSeleccionada, ya se se mueve la ficha
	                    flagSalto =false;
	                    flag = false;
	                    numsalto = 0;
	                    if(tablero.jugadores[turno-1].esPC && !detenerJuego)
	            		{
	            			mover_pc();
	            		}
	                    
	                    break label0;
	              	}
	              	else //no se puede realizar el movimiento
	              	{
	              		lAviso.setText("¡ERROR! El movimiento es incorrecto, no se puede realizar");
	              		
	              		/////////////////////SONIDOOOOOOOOOOOOOOOOOOOOOOOOO
	              		//soni.playSound("Sonido/Error.wav");
	              		////////////////////////////////////////////////
	              	}          	  
	      
	    	  		}
	    		}
	   
	    	}
		 	}//FIN TIPOTABLE == 3
		 	if (tipotabl == 5)
		 	{
		 		if(tablero.jugadores[turno-1].esPC && cuentaEmpezar==0)
			 	{
			 		cuentaEmpezar = 1;
		        	tiempo.start();
			 	}	 	
	    	
	    	//caso en el que hacemos un solo click
			 	if(mouseevent.getClickCount() == 1)
		    	{    		
		    		Graphics2D graphics2d = (Graphics2D)getGraphics();
		            int l = mouseevent.getX();
		            int k = mouseevent.getY();
		            
		            //if(l <= 20 || l >= 660 || k <=50 || k >= 690)
		            //if(l <= 200 || l >= 800 || k <=50 || k >= 690)
		            if(l <= 200 + 84 || l >= 662 + 84 || k <=50 || k >= 512)
		            	break label0;
	            
		            detenerJuego = false;
		            
		            if(compruebaGanador()!= 0)
		            {
		            	detenerJuego = true;
		            }
		            
		            if(tablero.jugadores[turno-1].esPC)
		            {
		            	mover_pc();
		            	
		            	if(detenerJuego)//Implica que se ha terminado la partida
		            	{
		            		muestraGanador();
		            	}
	                       	
		            }
		            
	///// MIRAR TODO ESTO LOS BUCLES Y TAL Y TAL ////////////////////////////////////
		            // No es PC, es jugador normal.
		            else
		            {
			            //Calcula la coordenada i,j del tablero (16x16) que se pincha
			            //int i = Math.round((l-20) / 80);
		            	//int i = Math.round((l-200) / 60);
				           // int j = Math.round((k-50) / 60);
		            	int i=8,j=8; 
			            if (l>=200 + 84 && l<=254 + 84)
			            {
			            	if (k>=50 && k<=104)
			            	{
			            		i = 0; 
			            		j = 0;
			            	}
			            	else if (k>=118 && k<=172)
			            	{
			            		i = 0;
			            		j = 1;
			            	}
			            	else if (k>=186 && k<=240)
			            	{
			            		i = 0;
			            		j = 2;
			            	}
			            	else if (k>=254 && k<=308)
			            	{
			            		i = 0;
			            		j = 3;
			            	}
			            	else if (k>=322 && k<=376)
			            	{
			            		i = 0;
			            		j = 4;
			            	}
			            	else if (k>=390 && k<=444)
			            	{
			            		i = 0;
			            		j = 5;
			            	}
			            	else if (k>=458 && k<=512)
			            	{
			            		i = 0;
			            		j = 6;
			            	}
			            }
			            else if (l>=268 + 84 && l<=322 + 84)
			            {
			            	if (k>=50 && k<=104)
			            	{
			            		i = 1; 
			            		j = 0;
			            	}
			            	else if (k>=118 && k<=172)
			            	{
			            		i = 1;
			            		j = 1;
			            	}
			            	else if (k>=186 && k<=240)
			            	{
			            		i = 1;
			            		j = 2;
			            	}
			            	else if (k>=254 && k<=308)
			            	{
			            		i = 1;
			            		j = 3;
			            	}
			            	else if (k>=322 && k<=376)
			            	{
			            		i = 1;
			            		j = 4;
			            	}
			            	else if (k>=390 && k<=444)
			            	{
			            		i = 1;
			            		j = 5;
			            	}
			            	else if (k>=458 && k<=512)
			            	{
			            		i = 1;
			            		j = 6;
			            	}
			            }
			            else if (l>=336 + 84 && l<=390 + 84)
			            {
			            	if (k>=50 && k<=104)
			            	{
			            		i = 2; 
			            		j = 0;
			            	}
			            	else if (k>=118 && k<=172)
			            	{
			            		i = 2;
			            		j = 1;
			            	}
			            	else if (k>=186 && k<=240)
			            	{
			            		i = 2;
			            		j = 2;
			            	}
			            	else if (k>=254 && k<=308)
			            	{
			            		i = 2;
			            		j = 3;
			            	}
			            	else if (k>=322 && k<=376)
			            	{
			            		i = 2;
			            		j = 4;
			            	}
			            	else if (k>=390 && k<=444)
			            	{
			            		i = 2;
			            		j = 5;
			            	}
			            	else if (k>=458 && k<=512)
			            	{
			            		i = 2;
			            		j = 6;
			            	}
			            }
			            else if (l>=404 + 84 && l<=458 + 84)
			            {
			            	if (k>=50 && k<=104)
			            	{
			            		i = 3; 
			            		j = 0;
			            	}
			            	else if (k>=118 && k<=172)
			            	{
			            		i = 3;
			            		j = 1;
			            	}
			            	else if (k>=186 && k<=240)
			            	{
			            		i = 3;
			            		j = 2;
			            	}
			            	else if (k>=254 && k<=308)
			            	{
			            		i = 3;
			            		j = 3;
			            	}
			            	else if (k>=322 && k<=376)
			            	{
			            		i = 3;
			            		j = 4;
			            	}
			            	else if (k>=390 && k<=444)
			            	{
			            		i = 3;
			            		j = 5;
			            	}
			            	else if (k>=458 && k<=512)
			            	{
			            		i = 3;
			            		j = 6;
			            	}
			            }
			            else if (l>=472 + 84 && l<=526 + 84)
			            {
			            	if (k>=50 && k<=104)
			            	{
			            		i = 4; 
			            		j = 0;
			            	}
			            	else if (k>=118 && k<=172)
			            	{
			            		i = 4;
			            		j = 1;
			            	}
			            	else if (k>=186 && k<=240)
			            	{
			            		i = 4;
			            		j = 2;
			            	}
			            	else if (k>=254 && k<=308)
			            	{
			            		i = 4;
			            		j = 3;
			            	}
			            	else if (k>=322 && k<=376)
			            	{
			            		i = 4;
			            		j = 4;
			            	}
			            	else if (k>=390 && k<=444)
			            	{
			            		i = 4;
			            		j = 5;
			            	}
			            	else if (k>=458 && k<=512)
			            	{
			            		i = 4;
			            		j = 6;
			            	}
			            }
			            else if (l>=540 + 84 && l<=594 + 84)
			            {
			            	if (k>=50 && k<=104)
			            	{
			            		i = 5; 
			            		j = 0;
			            	}
			            	else if (k>=118 && k<=172)
			            	{
			            		i = 5;
			            		j = 1;
			            	}
			            	else if (k>=186 && k<=240)
			            	{
			            		i = 5;
			            		j = 2;
			            	}
			            	else if (k>=254 && k<=308)
			            	{
			            		i = 5;
			            		j = 3;
			            	}
			            	else if (k>=322 && k<=376)
			            	{
			            		i = 5;
			            		j = 4;
			            	}
			            	else if (k>=390 && k<=444)
			            	{
			            		i = 5;
			            		j = 5;
			            	}
			            	else if (k>=458 && k<=512)
			            	{
			            		i = 5;
			            		j = 6;
			            	}
			            }
			            else if (l>=608 + 84 && l<=662 + 84)
			            {
			            	if (k>=50 && k<=104)
			            	{
			            		i = 6; 
			            		j = 0;
			            	}
			            	else if (k>=118 && k<=172)
			            	{
			            		i = 6;
			            		j = 1;
			            	}
			            	else if (k>=186 && k<=240)
			            	{
			            		i = 6;
			            		j = 2;
			            	}
			            	else if (k>=254 && k<=308)
			            	{
			            		i = 6;
			            		j = 3;
			            	}
			            	else if (k>=322 && k<=376)
			            	{
			            		i = 6;
			            		j = 4;
			            	}
			            	else if (k>=390 && k<=444)
			            	{
			            		i = 6;
			            		j = 5;
			            	}
			            	else if (k>=458 && k<=512)
			            	{
			            		i = 6;
			            		j = 6;
			            	}
			            } 
		                     
			          //Si deseleccionamos la casilla seleccionada
			            if(seleccionada_posi == i && seleccionada_posj == j)
			            {
			                if(flagSalto)
			                {
			                	for (int a=15; a>0; a--)
			                	{
			                		if (saltos[a] != -1)
			                		{
			                			borrarCuadro(saltos[a]%7, saltos[a]/7);
			                		}
			                	}
			                }
	            	
			            	borrarCuadro(i, j);
			                borrarCuadro (candidata_posi, candidata_posj);
			                pintarPieza(tablero.casillas[XasociaCasilla(i,j)].numjugador, j, i, true);
			              
			                seleccionada_posj = -1;
			                seleccionada_posi = -1;	
			                candidata_posi = -1;
			                candidata_posj = -1;
			                
			                inicializaSaltos();
			                
			                saltos[0]= -1;
			                sal_borra[0] = -1;
			                vector_aux[0]=-1;
			                
			                break label0;
			            }            
	            
			            //Cuando seleccionamos
			            if(seleccionada_posi == -1 && seleccionada_posj == -1)
			            {	
			            	if (i>7 && j >7)
			            	{
			            		break label0;
			            	}
			            	//Si pinchamos en una casilla sin ficha (sin que haya nada seleccionado)
			            	if (tablero.casillas[XasociaCasilla(i,j)].ocupado == false)
			                    break label0;
		            	
			            	//Si pinchamos para seleccionar en una ficha cuyo turno no corresponde
			            	if(tablero.casillas[XasociaCasilla(i,j)].numjugador != turno)
			            		break label0;
		            	
			                seleccionada_posi = i;
			                seleccionada_posj = j;
		                               
		                
			                //Para comenzar el tiempo la primera vez que pinchemos
			                if(cuentaEmpezar==0)
			                {	
			                	cuentaEmpezar = 1;
			                	tiempo.start();
			                }
			              
			                dibujaSeleccion(i, j);
			                
			                saltos[0] = XasociaCasilla(seleccionada_posi, seleccionada_posj); 
			                //System.out.println("buaahh " + saltos[0]);
			            }
			            
			            else //Caso en el que haya una ficha seleccionada y pincha en otra casilla 
			            {
			            	if (i>7 && j >7)
			            	{
			            		if(flagSalto)
				                {
				                	for (int a=15; a>0; a--)
				                	{
				                		if (saltos[a] != -1)
				                		{
				                			borrarCuadro(saltos[a]%7, saltos[a]/7);
				                		}
				                	}
				                }
		            	
				            	borrarCuadro(i, j);
				                borrarCuadro (candidata_posi, candidata_posj);
				                borrarCuadro (i, j);
				                pintarPieza(tablero.casillas[XasociaCasilla(seleccionada_posi,seleccionada_posj)].numjugador, seleccionada_posj, seleccionada_posi, true);
				                seleccionada_posj = -1;
				                seleccionada_posi = -1;	
				                inicializaSaltos();
				                saltos[0]= -1;
				                sal_borra[0] = -1;
				                vector_aux[0]=-1;
			            		break label0;
			            	}
			            	if(seleccionada_posi != i || seleccionada_posj != j)
			            	{            		
			             	 	if(tablero.casillas[XasociaCasilla(i,j)].ocupado == false)
			             	 	{ 
	//Se activa cuando hay posibilidad de movimiento (espera un nuevo click a esa posicion para ejecutar el cambio)
	             	 	            flag = false;
			             	 	    numCasillaCandidata = XasociaCasilla(i, j);
			         	 			numCasillaSeleccionada = XasociaCasilla(seleccionada_posi, seleccionada_posj);
			         	 			if (saltos[0] == -1)
			         	 			{
			         	 				saltos[0] = numCasillaSeleccionada; //La casilla seleccionada de verdad
			         	 				System.out.println("la casilla d verdad " + saltos[0]);
			         	 			}
	         	 			
			         	 			if(tablero.casillas[numCasillaSeleccionada].numjugador == 1)
			         	 			{
			         	 				//Tratamos el movimiento simple (para el jugador 1 y para el jugador 3)
			         	 				
			         	 			////////////////////////////////////////////////
			         	 				//MIOOOOOOOOOOOOOOOOO
			         	 			//////////////////////////////////////////////////
			         	 				if (Cruz_restri.adyacentes[numCasillaSeleccionada][0] == numCasillaCandidata)
			         	 				{
			         	 					for (int a=15; a>0; a--)
			         	 					{
			         	 						if (saltos[a] != -1)
			         	 						{
			         	 							borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 						}
			         	 					}
			                 	 			flag = true;
			                 	 			flagSalto = false;
			                 	 			inicializaSaltos();
			         	 				}
			         	 				else
			         	 					if (Cruz_restri.adyacentes[numCasillaSeleccionada][1] == numCasillaCandidata)
				         	 				{
				         	 					for (int a=15; a>0; a--)
				         	 					{
				         	 						if (saltos[a] != -1)
				         	 						{
				         	 							borrarCuadro(saltos[a]%7, saltos[a]/7);
				         	 						}
				         	 					}
				                 	 			flag = true;
				                 	 			flagSalto = false;
				                 	 			inicializaSaltos();
				         	 				}
			         	 					else
			         	 						if (Cruz_restri.adyacentes[numCasillaSeleccionada][2] == numCasillaCandidata)
					         	 				{
					         	 					for (int a=15; a>0; a--)
					         	 					{
					         	 						if (saltos[a] != -1)
					         	 						{
					         	 							borrarCuadro(saltos[a]%7, saltos[a]/7);
					         	 						}
					         	 					}
					                 	 			flag = true;
					                 	 			flagSalto = false;
					                 	 			inicializaSaltos();
					         	 				}
			         	 						else
			         	 				
			   //////////////////////////////////////////////////////////////////////////////////////////////
			         	 				
			         	 				
			         	 				
			         	 				if (Cruz_restri.adyacentes[numCasillaSeleccionada][3] == numCasillaCandidata)
			         	 				{
			         	 					for (int a=15; a>0; a--)
			         	 					{
			         	 						if (saltos[a] != -1)
			         	 						{
			         	 							borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 						}
			         	 					}
			                 	 			flag = true;
			                 	 			flagSalto = false;
			                 	 			inicializaSaltos();
			         	 				}
			         	 				
			         	 				else 
			         	 					if (Cruz_restri.adyacentes[numCasillaSeleccionada][4] == numCasillaCandidata)
			         	 					{
			         	 						for (int a=15; a>0; a--)
			         	 						{
			         	 							if (saltos[a] != -1)
			         	 							{
			         	 								borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 							}
			         	 						}
			         	 						flag = true;
			         	 						flagSalto = false;
			         	 						inicializaSaltos();
			         	 					}
			         	 					else 
			         	 						if (Cruz_restri.adyacentes[numCasillaSeleccionada][5] == numCasillaCandidata)
			         	 						{
			         	 							for (int a=15; a>0; a--)
			         	 							{
			         	 								if (saltos[a] != -1)
			         	 								{
			         	 									borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 								}
			         	 							}
			         	 							flag = true;
			         	 							flagSalto = false;
			         	 							inicializaSaltos();
			         	 						}
			         	 						else 
			         	 							if (Cruz_restri.adyacentes[numCasillaSeleccionada][6] == numCasillaCandidata)
			         	 							{
			         	 								for (int a=15; a>0; a--)
			         	 								{
			         	 									if (saltos[a] != -1)
			         	 									{
			         	 										borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 									}
			         	 								}
			         	 								flag = true;
			         	 								flagSalto = false;
			         	 								inicializaSaltos();
			         	 							}
			         	 							else 
			         	 								if (Cruz_restri.adyacentes[numCasillaSeleccionada][7] == numCasillaCandidata)
			         	 								{
			         	 									for (int a=15; a>0; a--)
			         	 									{
			         	 										if (saltos[a] != -1)
			         	 										{
			         	 											borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 										}
			         	 									}
			         	 									flag = true;
			         	 									flagSalto = false;
			         	 									inicializaSaltos();
			         	 								}
	             	 			
			         	 			}
	          	 		
			         	 			else 
			         	 				if(tablero.casillas[numCasillaSeleccionada].numjugador == 2)
			         	 						//|| tablero.casillas[numCasillaSeleccionada].numjugador == 4)
			         	 				{
	             	 			//Tratamos el movimiento simple (para el jugador 2 y para el jugador 4)
	             	 			
			         	 					if (Cruz_restri.adyacentes[numCasillaSeleccionada][0] == numCasillaCandidata)
			         	 					{
			         	 						for (int a=15; a>0; a--)
			         	 						{
			         	 							if (saltos[a] != -1)
			         	 							{
			         	 								borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 							}
			         	 						}
			         	 						flag = true;
			         	 						flagSalto = false;
			         	 						inicializaSaltos();
			         	 					}
			         	 					else 
			         	 						if (Cruz_restri.adyacentes[numCasillaSeleccionada][1] == numCasillaCandidata)
			         	 						{
			         	 							for (int a=15; a>0; a--)
			         	 							{
			         	 								if (saltos[a] != -1)
			         	 								{
			         	 									borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 								}
			         	 							}
			         	 							flag = true;
			         	 							flagSalto = false;
			         	 							inicializaSaltos();
			         	 						}
			         	 						else 
			         	 							if (Cruz_restri.adyacentes[numCasillaSeleccionada][2] == numCasillaCandidata)
			         	 							{
			         	 								for (int a=15; a>0; a--)
			         	 								{
			         	 									if (saltos[a] != -1)
			         	 									{
			         	 										borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 									}
			         	 								}
			         	 								flag = true;
			         	 								flagSalto = false;
			         	 								inicializaSaltos();
			         	 							}
			         	 							else 
			         	 								if (Cruz_restri.adyacentes[numCasillaSeleccionada][3] == numCasillaCandidata)
			         	 								{
			         	 									for (int a=15; a>0; a--)
			         	 									{
			         	 										if (saltos[a] != -1)
			         	 										{
			         	 											borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 										}
			         	 									}
			         	 									flag = true;
			         	 									flagSalto = false;
			         	 									inicializaSaltos();
			         	 								}
			         	 								else 
			         	 									if (Cruz_restri.adyacentes[numCasillaSeleccionada][4] == numCasillaCandidata)
			         	 									{
			         	 										for (int a=15; a>0; a--)
			         	 										{
			         	 											if (saltos[a] != -1)
			         	 											{
			         	 												borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 											}
			         	 										}
			         	 										flag = true;
			         	 										flagSalto = false;
			         	 										inicializaSaltos();
			         	 									}
			         	 					
			         	 ////////////////////////////////////////////////////////////////////////////////
			         	 					//MIOOOOOOOOOOOOOOOOOOOOOOOO
			         	 ////////////////////////////////////////////////////////////////////////////////					
	             	 			
			         	 									else 
				         	 									if (Cruz_restri.adyacentes[numCasillaSeleccionada][5] == numCasillaCandidata)
				         	 									{
				         	 										for (int a=15; a>0; a--)
				         	 										{
				         	 											if (saltos[a] != -1)
				         	 											{
				         	 												borrarCuadro(saltos[a]%7, saltos[a]/7);
				         	 											}
				         	 										}
				         	 										flag = true;
				         	 										flagSalto = false;
				         	 										inicializaSaltos();
				         	 									}
				         	 									else 
					         	 									if (Cruz_restri.adyacentes[numCasillaSeleccionada][6] == numCasillaCandidata)
					         	 									{
					         	 										for (int a=15; a>0; a--)
					         	 										{
					         	 											if (saltos[a] != -1)
					         	 											{
					         	 												borrarCuadro(saltos[a]%7, saltos[a]/7);
					         	 											}
					         	 										}
					         	 										flag = true;
					         	 										flagSalto = false;
					         	 										inicializaSaltos();
					         	 									}
					         	 									else 
						         	 									if (Cruz_restri.adyacentes[numCasillaSeleccionada][7] == numCasillaCandidata)
						         	 									{
						         	 										for (int a=15; a>0; a--)
						         	 										{
						         	 											if (saltos[a] != -1)
						         	 											{
						         	 												borrarCuadro(saltos[a]%7, saltos[a]/7);
						         	 											}
						         	 										}
						         	 										flag = true;
						         	 										flagSalto = false;
						         	 										inicializaSaltos();
						         	 									}
			         	 	////////////////////////////////////////////////////////////////////////////////////////////////////////////				
			         	 					
			         	 					//Tratamos la situacion de un salto (para el jugador 2 y para el jugador 4)
	             	 			
			         	 				if (Cruz_restri.adyacentes[saltos[0]][0] != -1 &&
			         	 						tablero.casillas[XasociaCasilla(Cruz_restri.adyacentes[saltos[0]][0]%7,Cruz_restri.adyacentes[saltos[0]][0]/7)].ocupado == true &&
			         	 						Cruz_restri.adyacentes[Cruz_restri.adyacentes[saltos[0]][0]][0] == numCasillaCandidata)
			         	 				{
			         	 					sal_borra[numsalto] = XasociaCasilla(Cruz_restri.adyacentes[saltos[numsalto]][0]%7,Cruz_restri.adyacentes[saltos[numsalto]][0]/7);
			         	 					flag = true;
			         	 					if (Cruz_restri.adyacentes[saltos[0]][0] != -1 &&
			         	 						tablero.casillas[XasociaCasilla(Cruz_restri.adyacentes[saltos[0]][0]%7,Cruz_restri.adyacentes[saltos[0]][0]/7)].ocupado == true &&
			         	 						Cruz_restri.adyacentes[Cruz_restri.adyacentes[saltos[0]][0]][0] == numCasillaCandidata)
			         	 					{
			         	 						for (int a=15; a>0; a--)
			         	 						{
			         	 							if (saltos[a] != -1)
			         	 							{
			         	 								borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 							}
			         	 						}
			         	 						inicializaSaltos();
			         	 					}
			         	 					else
			         	 						if (flagSalto == false)
			         	 						{
			         	 							inicializaSaltos();
			         	 						}
			         	 						flagSalto = true;
			         	 						numsalto++; //Aumentamos en uno el numero de salto
			         	 						saltos[numsalto] = numCasillaCandidata;
			         	 				}
			         	 				else 
			         	 					if (Cruz_restri.adyacentes[saltos[0]][1] != -1 &&
			         	 							tablero.casillas[XasociaCasilla(Cruz_restri.adyacentes[saltos[0]][1]%7,Cruz_restri.adyacentes[saltos[0]][1]/7)].ocupado == true &&
			         	 							Cruz_restri.adyacentes[Cruz_restri.adyacentes[saltos[0]][1]][1] == numCasillaCandidata)
			         	 					{
			         	 						sal_borra[numsalto] = XasociaCasilla(Cruz_restri.adyacentes[saltos[numsalto]][1]%7,Cruz_restri.adyacentes[saltos[numsalto]][1]/7);
			         	 						flag = true;
			         	 						if (Cruz_restri.adyacentes[saltos[0]][1] != -1 &&
			         	 								tablero.casillas[XasociaCasilla(Cruz_restri.adyacentes[saltos[0]][1]%7,Cruz_restri.adyacentes[saltos[0]][1]/7)].ocupado == true &&
			         	 								Cruz_restri.adyacentes[Cruz_restri.adyacentes[saltos[0]][1]][1] == numCasillaCandidata)
			         	 						{
			         	 							for (int a=15; a>0; a--)
			         	 							{
			         	 								if (saltos[a] != -1)
			         	 								{
			         	 									borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 								}
			         	 							}
			         	 							inicializaSaltos();
			         	 						}
			         	 						else 
			         	 							if (flagSalto == false)
			         	 							{
			         	 								inicializaSaltos();
			         	 							}
			         	 							flagSalto = true;
			         	 							numsalto++; //Aumentamos en uno el numero de salto
			         	 							saltos[numsalto] = numCasillaCandidata;
			         	 					}
			         	 					else 
			         	 						if (Cruz_restri.adyacentes[saltos[0]][2] != -1 &&
			         	 								tablero.casillas[XasociaCasilla(Cruz_restri.adyacentes[saltos[0]][2]%7,Cruz_restri.adyacentes[saltos[0]][2]/7)].ocupado == true &&
			         	 								Cruz_restri.adyacentes[Cruz_restri.adyacentes[saltos[0]][2]][2] == numCasillaCandidata)
			         	 						{
			         	 							sal_borra[numsalto] = XasociaCasilla(Cruz_restri.adyacentes[saltos[numsalto]][2]%7,Cruz_restri.adyacentes[saltos[numsalto]][2]/7);
			         	 							flag = true;
			         	 							if (Cruz_restri.adyacentes[saltos[0]][2] != -1 &&
			         	 									tablero.casillas[XasociaCasilla(Cruz_restri.adyacentes[saltos[0]][2]%7,Cruz_restri.adyacentes[saltos[0]][2]/7)].ocupado == true &&
			         	 									Cruz_restri.adyacentes[Cruz_restri.adyacentes[saltos[0]][2]][2] == numCasillaCandidata)
			         	 							{
			         	 								for (int a=15; a>0; a--)
			         	 								{
			         	 									if (saltos[a] != -1)
			         	 									{
			         	 										borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 									}
			         	 								}
			         	 								inicializaSaltos();
			         	 							}
			         	 							else 
			         	 								if (flagSalto == false)
			         	 								{
			         	 									inicializaSaltos();
			         	 								}
			         	 								flagSalto = true;
			         	 								numsalto++; //Aumentamos en uno el numero de salto
			         	 								saltos[numsalto] = numCasillaCandidata;
			         	 						}
			         	 						else 
			         	 							if (Cruz_restri.adyacentes[saltos[0]][3] != -1 &&
			         	 									tablero.casillas[XasociaCasilla(Cruz_restri.adyacentes[saltos[0]][3]%7,Cruz_restri.adyacentes[saltos[0]][3]/7)].ocupado == true &&
			         	 									Cruz_restri.adyacentes[Cruz_restri.adyacentes[saltos[0]][3]][3] == numCasillaCandidata)
			         	 							{
			         	 								System.out.println("Saltos 0 vale " + saltos[0]);
			         	 								System.out.println("Saltos numsalto vale " + saltos[numsalto]);
			         	 								System.out.println("el %16 vale " + Cruz_restri.adyacentes[saltos[numsalto]][3]%7 + " y el /16 vale " + SieteX.adyacentes[saltos[numsalto]][3]/7);
			         	 								
			         	 								sal_borra[numsalto] = XasociaCasilla(Cruz_restri.adyacentes[saltos[numsalto]][3]%7,Cruz_restri.adyacentes[saltos[numsalto]][3]/7);
			         	 								System.out.println("El valor de sal_borra[0] es " + sal_borra[0]);
			         	 								System.out.println("num salto vale " + numsalto);
			         	 								flag = true;
			         	 								if (Cruz_restri.adyacentes[saltos[0]][3] != -1 &&
			         	 										tablero.casillas[XasociaCasilla(Cruz_restri.adyacentes[saltos[0]][3]%7,Cruz_restri.adyacentes[saltos[0]][3]/7)].ocupado == true &&
			         	 										Cruz_restri.adyacentes[Cruz_restri.adyacentes[saltos[0]][3]][3] == numCasillaCandidata)
			         	 								{
			         	 									for (int a=15; a>0; a--)
			         	 									{
			         	 										if (saltos[a] != -1)
			         	 										{
			         	 											borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 										}
			         	 			        				}
			         	 									inicializaSaltos();
			         	 								}
			         	 								else 
			         	 									if (flagSalto == false)
			         	 									{
			         	 										inicializaSaltos();
			         	 									}
			         	 									flagSalto = true;
			         	 									numsalto++; //Aumentamos en uno el numero de salto
			         	 									saltos[numsalto] = numCasillaCandidata;
			         	 							}
			         	 							else
			         	 								if (Cruz_restri.adyacentes[saltos[0]][4] != -1 &&
			         	 										tablero.casillas[XasociaCasilla(Cruz_restri.adyacentes[saltos[0]][4]%7,Cruz_restri.adyacentes[saltos[0]][4]/7)].ocupado == true &&
			         	 										Cruz_restri.adyacentes[Cruz_restri.adyacentes[saltos[0]][4]][4] == numCasillaCandidata)
			         	 								{
			         	 									sal_borra[numsalto] = XasociaCasilla(Cruz_restri.adyacentes[saltos[numsalto]][4]%7,Cruz_restri.adyacentes[saltos[numsalto]][4]/7);
			         	 									flag = true;
			         	 									if (Cruz_restri.adyacentes[saltos[0]][4] != -1 &&
			         	 											tablero.casillas[XasociaCasilla(Cruz_restri.adyacentes[saltos[0]][4]%7,Cruz_restri.adyacentes[saltos[0]][4]/7)].ocupado == true &&
			         	 											Cruz_restri.adyacentes[Cruz_restri.adyacentes[saltos[0]][4]][4] == numCasillaCandidata)
			         	 									{
			         	 										for (int a=15; a>0; a--)
			         	 										{
			         	 											if (saltos[a] != -1)
			         	 											{
			         	 												borrarCuadro(saltos[a]%7, saltos[a]/7);
			         	 											}
			         	 										}
			         	 										inicializaSaltos();
			         	 									}
			         	 									else 
			         	 										if (flagSalto == false)
			         	 										{
			         	 											inicializaSaltos();
			         	 										}
			         	 										flagSalto = true;
			         	 										numsalto++; //Aumentamos en uno el numero de salto
			         	 										saltos[numsalto] = numCasillaCandidata;
			         	 								}
			         	 				
			       ////////////////////////////////////////////////////////////////////////////
			         	 				//MIO
			       /////////////////////////////////////////////////////////////////////////////
			         	 				
			         	 								else
				         	 								if (Cruz_restri.adyacentes[saltos[0]][5] != -1 &&
				         	 										tablero.casillas[XasociaCasilla(Cruz_restri.adyacentes[saltos[0]][5]%7,Cruz_restri.adyacentes[saltos[0]][5]/7)].ocupado == true &&
				         	 										Cruz_restri.adyacentes[Cruz_restri.adyacentes[saltos[0]][5]][5] == numCasillaCandidata)
				         	 								{
				         	 									sal_borra[numsalto] = XasociaCasilla(Cruz_restri.adyacentes[saltos[numsalto]][5]%7,Cruz_restri.adyacentes[saltos[numsalto]][5]/7);
				         	 									flag = true;
				         	 									if (Cruz_restri.adyacentes[saltos[0]][5] != -1 &&
				         	 											tablero.casillas[XasociaCasilla(Cruz_restri.adyacentes[saltos[0]][5]%7,Cruz_restri.adyacentes[saltos[0]][5]/7)].ocupado == true &&
				         	 											Cruz_restri.adyacentes[Cruz_restri.adyacentes[saltos[0]][5]][5] == numCasillaCandidata)
				         	 									{
				         	 										for (int a=15; a>0; a--)
				         	 										{
				         	 											if (saltos[a] != -1)
				         	 											{
				         	 												borrarCuadro(saltos[a]%7, saltos[a]/7);
				         	 											}
				         	 										}
				         	 										inicializaSaltos();
				         	 									}
				         	 									else 
				         	 										if (flagSalto == false)
				         	 										{
				         	 											inicializaSaltos();
				         	 										}
				         	 										flagSalto = true;
				         	 										numsalto++; //Aumentamos en uno el numero de salto
				         	 										saltos[numsalto] = numCasillaCandidata;
				         	 								}
			         	 				
				         	 								else
					         	 								if (Cruz_restri.adyacentes[saltos[0]][6] != -1 &&
					         	 										tablero.casillas[XasociaCasilla(Cruz_restri.adyacentes[saltos[0]][6]%7,Cruz_restri.adyacentes[saltos[0]][6]/7)].ocupado == true &&
					         	 										Cruz_restri.adyacentes[Cruz_restri.adyacentes[saltos[0]][6]][6] == numCasillaCandidata)
					         	 								{
					         	 									sal_borra[numsalto] = XasociaCasilla(Cruz_restri.adyacentes[saltos[numsalto]][6]%7,Cruz_restri.adyacentes[saltos[numsalto]][6]/7);
					         	 									flag = true;
					         	 									if (Cruz_restri.adyacentes[saltos[0]][6] != -1 &&
					         	 											tablero.casillas[XasociaCasilla(Cruz_restri.adyacentes[saltos[0]][6]%7,Cruz_restri.adyacentes[saltos[0]][6]/7)].ocupado == true &&
					         	 											Cruz_restri.adyacentes[Cruz_restri.adyacentes[saltos[0]][6]][6] == numCasillaCandidata)
					         	 									{
					         	 										for (int a=15; a>0; a--)
					         	 										{
					         	 											if (saltos[a] != -1)
					         	 											{
					         	 												borrarCuadro(saltos[a]%7, saltos[a]/7);
					         	 											}
					         	 										}
					         	 										inicializaSaltos();
					         	 									}
					         	 									else 
					         	 										if (flagSalto == false)
					         	 										{
					         	 											inicializaSaltos();
					         	 										}
					         	 										flagSalto = true;
					         	 										numsalto++; //Aumentamos en uno el numero de salto
					         	 										saltos[numsalto] = numCasillaCandidata;
					         	 								}
					         	 								else
						         	 								if (Cruz_restri.adyacentes[saltos[0]][7] != -1 &&
						         	 										tablero.casillas[XasociaCasilla(Cruz_restri.adyacentes[saltos[0]][7]%7,Cruz_restri.adyacentes[saltos[0]][7]/7)].ocupado == true &&
						         	 										Cruz_restri.adyacentes[Cruz_restri.adyacentes[saltos[0]][7]][7] == numCasillaCandidata)
						         	 								{
						         	 									sal_borra[numsalto] = XasociaCasilla(Cruz_restri.adyacentes[saltos[numsalto]][7]%7,Cruz_restri.adyacentes[saltos[numsalto]][7]/7);
						         	 									flag = true;
						         	 									if (Cruz_restri.adyacentes[saltos[0]][7] != -1 &&
						         	 											tablero.casillas[XasociaCasilla(Cruz_restri.adyacentes[saltos[0]][7]%7,Cruz_restri.adyacentes[saltos[0]][7]/7)].ocupado == true &&
						         	 											Cruz_restri.adyacentes[Cruz_restri.adyacentes[saltos[0]][7]][7] == numCasillaCandidata)
						         	 									{
						         	 										for (int a=15; a>0; a--)
						         	 										{
						         	 											if (saltos[a] != -1)
						         	 											{
						         	 												borrarCuadro(saltos[a]%7, saltos[a]/7);
						         	 											}
						         	 										}
						         	 										inicializaSaltos();
						         	 									}
						         	 									else 
						         	 										if (flagSalto == false)
						         	 										{
						         	 											inicializaSaltos();
						         	 										}
						         	 										flagSalto = true;
						         	 										numsalto++; //Aumentamos en uno el numero de salto
						         	 										saltos[numsalto] = numCasillaCandidata;
						         	 								}
			         	 				
			         	 	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
			         	 				
	             	 			
			         	 				}

			         	 			if (flagSalto && flag)
			         	 			{
			         	 				if (numsalto == 1) //Para borrar las selecciones cuando se pivota con casillaSeleccionada
			         	 				{
			         	 					//System.out.println(numsalto);
			         	 					borrarCuadro (candidata_posi, candidata_posj);
			         	 				}
			         	 				candidata_posi = i;
			         	 				candidata_posj = j;
			         	 				dibujaCandidata(i,j);
			         	 				dibujaSeleccion(saltos[0]%7, saltos[0]/7);
			         	 				//System.out.println("salto???");
			         	 			}
	         	 			
			         	 			if(flag)
			         	 			{
	                			//Entramos aqui si ya esta seleccionada la posicion a la que
	                			//queremos mover y se esta esperando otro click ahi
	                			
	             	 			               			
	             	 		//hay ya una casilla seleccionada y la tenemos que quitar
			         	 				if (candidata_posi != -1 && candidata_posj != -1)
			         	 				{
			         	 					borrarCuadro (candidata_posi, candidata_posj);
			         	 					
			         	 				}
	                			
			         	 				candidata_posi = i;
			         	 				candidata_posj = j;
			         	 				dibujaCandidata(i,j);
			         	 				dibujaSeleccion(saltos[0]%7, saltos[0]/7);
			         	 				//System.out.println("JAVIsdfgsdf");
			         	 			}
			         	 			else
			         	 			{
			         	 				//Si el flag no esta activo no se hace nada (no hay seleccion ninguna)
			         	 			}
			             	 	}	
	             	 	
			            	}
	            }}
	    	}
	    	
		
	    	else  //caso en el que hacemos doble click
	    	{
	    		if(mouseevent.getClickCount()==2)
	    		{
	    			//System.out.println("JAVI");
	    			Graphics2D graphics2d = (Graphics2D)getGraphics();
	    			int l = mouseevent.getX();
	    			int k = mouseevent.getY();
	    			//if(l <= 20 || l >= 660 || k <=50 || k >= 690)
	    			//if(l <= 200 || l >= 800 || k <=50 || k >= 690)
	    			if(l <= 200 + 84 || l >= 662 + 84 || k <=50 || k >= 512)    
	    			{
	    				break label0;
	    			}
	            
	    			//int i = Math.round((l-20) / 80);
	    			//int i = Math.round((l-200) / 60);
			           // int j = Math.round((k-50) / 60);
	    			int i=0,j=0; 
		            if (l>=200 + 84 && l<=254 + 84)
		            {
		            	if (k>=50 && k<=104)
		            	{
		            		i = 0; 
		            		j = 0;
		            	}
		            	else if (k>=118 && k<=172)
		            	{
		            		i = 0;
		            		j = 1;
		            	}
		            	else if (k>=186 && k<=240)
		            	{
		            		i = 0;
		            		j = 2;
		            	}
		            	else if (k>=254 && k<=308)
		            	{
		            		i = 0;
		            		j = 3;
		            	}
		            	else if (k>=322 && k<=376)
		            	{
		            		i = 0;
		            		j = 4;
		            	}
		            	else if (k>=390 && k<=444)
		            	{
		            		i = 0;
		            		j = 5;
		            	}
		            	else if (k>=458 && k<=512)
		            	{
		            		i = 0;
		            		j = 6;
		            	}
		            }
		            else if (l>=268 + 84 && l<=322 + 84)
		            {
		            	if (k>=50 && k<=104)
		            	{
		            		i = 1; 
		            		j = 0;
		            	}
		            	else if (k>=118 && k<=172)
		            	{
		            		i = 1;
		            		j = 1;
		            	}
		            	else if (k>=186 && k<=240)
		            	{
		            		i = 1;
		            		j = 2;
		            	}
		            	else if (k>=254 && k<=308)
		            	{
		            		i = 1;
		            		j = 3;
		            	}
		            	else if (k>=322 && k<=376)
		            	{
		            		i = 1;
		            		j = 4;
		            	}
		            	else if (k>=390 && k<=444)
		            	{
		            		i = 1;
		            		j = 5;
		            	}
		            	else if (k>=458 && k<=512)
		            	{
		            		i = 1;
		            		j = 6;
		            	}
		            }
		            else if (l>=336 + 84 && l<=390 + 84)
		            {
		            	if (k>=50 && k<=104)
		            	{
		            		i = 2; 
		            		j = 0;
		            	}
		            	else if (k>=118 && k<=172)
		            	{
		            		i = 2;
		            		j = 1;
		            	}
		            	else if (k>=186 && k<=240)
		            	{
		            		i = 2;
		            		j = 2;
		            	}
		            	else if (k>=254 && k<=308)
		            	{
		            		i = 2;
		            		j = 3;
		            	}
		            	else if (k>=322 && k<=376)
		            	{
		            		i = 2;
		            		j = 4;
		            	}
		            	else if (k>=390 && k<=444)
		            	{
		            		i = 2;
		            		j = 5;
		            	}
		            	else if (k>=458 && k<=512)
		            	{
		            		i = 2;
		            		j = 6;
		            	}
		            }
		            else if (l>=404 + 84 && l<=458 + 84)
		            {
		            	if (k>=50 && k<=104)
		            	{
		            		i = 3; 
		            		j = 0;
		            	}
		            	else if (k>=118 && k<=172)
		            	{
		            		i = 3;
		            		j = 1;
		            	}
		            	else if (k>=186 && k<=240)
		            	{
		            		i = 3;
		            		j = 2;
		            	}
		            	else if (k>=254 && k<=308)
		            	{
		            		i = 3;
		            		j = 3;
		            	}
		            	else if (k>=322 && k<=376)
		            	{
		            		i = 3;
		            		j = 4;
		            	}
		            	else if (k>=390 && k<=444)
		            	{
		            		i = 3;
		            		j = 5;
		            	}
		            	else if (k>=458 && k<=512)
		            	{
		            		i = 3;
		            		j = 6;
		            	}
		            }
		            else if (l>=472 + 84 && l<=526 + 84)
		            {
		            	if (k>=50 && k<=104)
		            	{
		            		i = 4; 
		            		j = 0;
		            	}
		            	else if (k>=118 && k<=172)
		            	{
		            		i = 4;
		            		j = 1;
		            	}
		            	else if (k>=186 && k<=240)
		            	{
		            		i = 4;
		            		j = 2;
		            	}
		            	else if (k>=254 && k<=308)
		            	{
		            		i = 4;
		            		j = 3;
		            	}
		            	else if (k>=322 && k<=376)
		            	{
		            		i = 4;
		            		j = 4;
		            	}
		            	else if (k>=390 && k<=444)
		            	{
		            		i = 4;
		            		j = 5;
		            	}
		            	else if (k>=458 && k<=512)
		            	{
		            		i = 4;
		            		j = 6;
		            	}
		            }
		            else if (l>=540 + 84 && l<=594 + 84)
		            {
		            	if (k>=50 && k<=104)
		            	{
		            		i = 5; 
		            		j = 0;
		            	}
		            	else if (k>=118 && k<=172)
		            	{
		            		i = 5;
		            		j = 1;
		            	}
		            	else if (k>=186 && k<=240)
		            	{
		            		i = 5;
		            		j = 2;
		            	}
		            	else if (k>=254 && k<=308)
		            	{
		            		i = 5;
		            		j = 3;
		            	}
		            	else if (k>=322 && k<=376)
		            	{
		            		i = 5;
		            		j = 4;
		            	}
		            	else if (k>=390 && k<=444)
		            	{
		            		i = 5;
		            		j = 5;
		            	}
		            	else if (k>=458 && k<=512)
		            	{
		            		i = 5;
		            		j = 6;
		            	}
		            }
		            else if (l>=608 + 84 && l<=662 + 84)
		            {
		            	if (k>=50 && k<=104)
		            	{
		            		i = 6; 
		            		j = 0;
		            	}
		            	else if (k>=118 && k<=172)
		            	{
		            		i = 6;
		            		j = 1;
		            	}
		            	else if (k>=186 && k<=240)
		            	{
		            		i = 6;
		            		j = 2;
		            	}
		            	else if (k>=254 && k<=308)
		            	{
		            		i = 6;
		            		j = 3;
		            	}
		            	else if (k>=322 && k<=376)
		            	{
		            		i = 6;
		            		j = 4;
		            	}
		            	else if (k>=390 && k<=444)
		            	{
		            		i = 6;
		            		j = 5;
		            	}
		            	else if (k>=458 && k<=512)
		            	{
		            		i = 6;
		            		j = 6;
		            	}
		            } 
	                        
	    			
	            //caso en el que no haya ninguna casilla seleccionada
	            if(seleccionada_posi == -1 && seleccionada_posj == -1)	
	            {
	            	break label0;
	            }
	            
	            //Habiendo una seleccionada, hacemos doble click en otra casilla
	    		if(seleccionada_posi != i || seleccionada_posj != j)
	            {
	    			borrarCuadro (candidata_posi, candidata_posj); // Para evitar que se quede una casilla candidata
	    							//dibujada cuando se hace un doble click incorrecto
	    			
	    			//actualizamos los indices de la casilla seleccionada
	    			candidata_posi = i;
	    			candidata_posj = j;
	    		
	    			if(flag)//se puede realizar el movimiento
	              	{
	    				if(!flagSalto)
	    				{
	    					for (int a=0; a<16; a++)
	                        {
	                        	if (saltos[a] != -1)
	                        	{
	                        		borrarCuadro(saltos[a]%7, saltos[a]/7);
	                        	}
	                        }
	    				}
	    				
	    				numCasillaSeleccionada = XasociaCasilla(seleccionada_posi, seleccionada_posj);
	    				numCasillaCandidata = XasociaCasilla(candidata_posi, candidata_posj);
	    				dibujaCandidata(i,j);
	    				numsalto = 0;
	    				if(flagSalto)
	                    {
	    					
	                    	for (int a=1; a<16; a++)
	                    	{
	                    		if (saltos[a-1] != -1 && saltos[a] != -1)
	                    		{
	                    			borrarCuadro(saltos[a-1]%7, saltos[a-1]/7);
	                    			parpadeo();
	                    			borrarCuadro(sal_borra[a-1]%7, sal_borra[a-1]/7);
	                    			pintarPieza(tablero.casillas[numCasillaSeleccionada].numjugador, saltos[a]/7, saltos[a]%7, true);
	                    			//borrarCuadro(sal_borra[a-1]%5, sal_borra[a-1]/5);
	                    			numsalto++;
	                    			
	                    			parpadeo(); //Relentiza el proceso de dibujar los saltos
	                    			
	                    		}
	                    	}
	                    }
	                  
	    				borrarCuadro(seleccionada_posi, seleccionada_posj);
	    				
	    				//casilla_borrar = asociaCasilla(sal_borra[0]%5, sal_borra[0]/5);
	    				
	    				for (int a=0; a<16; a++)
	    				{
	    					//System.out.print(asociaCasilla(sal_borra[a]%5,sal_borra[a]/5) + ", ");
	    					if (sal_borra[a] != -1)
	    						vector_aux [a] = XasociaCasilla(sal_borra[a]%7, sal_borra[a]/7);
	    				}
	    				/*
	    				for (int a=0; a<16; a++)
	    					if (sal_borra[a] != -1)
	    						borrarCuadro(sal_borra[a]%5, sal_borra[a]/5);
	                	*/
	    				pintarPieza(tablero.casillas[numCasillaSeleccionada].numjugador, candidata_posj, candidata_posi, true);
	    				
	
	///////////////////////////////////    				///////////////////////////////
	                    //mover(numCasillaSeleccionada, numCasillaCandidata, casilla_borrar);
	                    mover(numCasillaSeleccionada, numCasillaCandidata, vector_aux);
	                    for (int a = 0; a<16;a++){
	                    	vector_aux[a] = -1;
	                    	sal_borra[a] = -1;
	                    }
	     ////////////////////////////////////////////////                    /////////////////////////////
	                    if(compruebaGanador()!=0)
	                    {
	                    	detenerJuego = true;
	                    	muestraGanador();
	                    }
	                    
	                    seleccionada_posj = -1;
	                    seleccionada_posi = -1;	
	                    candidata_posi = -1;
	                    candidata_posj = -1;
	                    inicializaSaltos();
	                    saltos[0]= -1; //Desanclamos el numCasillaSeleccionada, ya se se mueve la ficha
	                    flagSalto =false;
	                    flag = false;
	                    numsalto = 0;
	                    if(tablero.jugadores[turno-1].esPC && !detenerJuego)
	            		{
	            			mover_pc();
	            		}
	                    
	                    break label0;
	              	}
	              	else //no se puede realizar el movimiento
	              	{
	              		lAviso.setText("¡ERROR! El movimiento es incorrecto, no se puede realizar");
	              		
	              		/////////////////////SONIDOOOOOOOOOOOOOOOOOOOOOOOOO
	              		//soni.playSound("Sonido/Error.wav");
	              		////////////////////////////////////////////////
	              	}          	  
	      
	    	  		}
	    		}
	   
	    	}
		 	}//FIN TIPOTABLE == 5
	}
   }
    
    
   public void mousePressed(MouseEvent mouseevent){}
   public void mouseReleased(MouseEvent mouseevent){}
   public void mouseEntered(MouseEvent mouseevent) {}
   public void mouseExited(MouseEvent mouseevent){}

   
   //DibujaCandidata antes era seleccionar
   public void dibujaCandidata(int i,int j)
   {
   	int a=0;
        	while (a<1) 
        	{
        		a++;
				pintarPieza(30,j,i,true);
			try { 
				 Thread.sleep(100);
			} catch (InterruptedException e) {}
		}
   }
   
   public void parpadeo(){
   	int a=0;
        	while (a<3) 
        	{
        		a++;
			try 
			{ 
				 Thread.sleep(200);
			} 
			catch (InterruptedException e) {}
		}
   }
   
	public void dibujaSeleccion (int i, int j)
	{
		Graphics2D graphics2d = (Graphics2D)getGraphics();
		if (tipotabl == 1 || tipotabl == 4)
		{
			graphics2d.setColor(Color.BLUE);
			//graphics2d.setColor(Color.blue); //color de la seleccion
	    	graphics2d.setStroke(new BasicStroke(4.0F)); //grosor
	    	//graphics2d.drawRect(80 * i+20,80*j+50,79,79);
	    	graphics2d.drawRect(70 * i+270 + 25*i,70*j+50 + 25*j,69,69);
		}
		if (tipotabl == 2 || tipotabl == 6)
		{
			graphics2d.setColor(Color.BLUE);
			//graphics2d.setColor(Color.blue); //color de la seleccion
	    	graphics2d.setStroke(new BasicStroke(2.0F)); //grosor
	    	//graphics2d.drawRect(80 * i+20,80*j+50,79,79);
	    	graphics2d.drawRect(54*i+ 200 + 84 + 14*i,54*j+50+14*j,53,53);
		}
		if (tipotabl == 3 || tipotabl == 5)
		{
			graphics2d.setColor(Color.BLUE);
			//graphics2d.setColor(Color.blue); //color de la seleccion
	    	graphics2d.setStroke(new BasicStroke(2.0F)); //grosor
	    	//graphics2d.drawRect(80 * i+20,80*j+50,79,79);
	    	graphics2d.drawRect(54*i + 200 + 84 + 14*i, 54*j + 50+ 14*j,53,53);
		}
	}
	
	public void mover (int numCasillaSeleccionada, int numCasillaCandidata, int casilla_borrar[])
	{
		int b, aux;
		Casilla casillaaux;
		boolean fin = false;
		
		if (tipotabl == 1 || tipotabl == 4)
		{
			int numficha = tablero.casillas[numCasillaSeleccionada].numficha;
			int numcasilla = tablero.casillas[numCasillaSeleccionada].numcasilla;
			int numcascan = tablero.casillas[numCasillaCandidata].numcasilla;
			int quitaficha = -1;
			int quitacasilla = -1;
		
			int numjug = turno;
			
			numMovimientos++;
			lNumMovimientos.setText("Nº Movimientos: " + numMovimientos);
	
			if (turno==1)
			{
				tablero.casillas[numcascan] = new Casilla (numficha,turno,numcascan);
				
		        //Actualizamos los valores de la casilla candidata 		
				tablero.casillas[numcascan].colocarFichaEnCandidata(numficha, numjug);
				
				//Actualizamos las caracteristicas de la casilla hacia la que se mueve la ficha 		
				tablero.jugadores[numjug - 1].fichas[numficha].actualizarCasillaFicha(numcascan);
				
				//Actualizamos los valores de la casilla seleccionada 		
				tablero.casillas[numcasilla] = new Casilla (numcasilla);
				
				//Actualizamos los valores de la casilla seleccionada 		
				tablero.casillas[numcasilla].quitarFichaEnSeleccionada();
		        
//				update(getGraphics());
						
				//Actualizamos las caraceristicas del movimiento realizado por el jugador que mueva		
				tablero.jugadores[numjug - 1].movimientos ++; 
				
				tablero.jugadores[numjug - 1].ultimaFicha = numficha;
				tablero.jugadores[numjug - 1].ultimaCasilla = numcasilla;
				update(getGraphics());

				//tablero.jugadores[numjug - 1].calcularDistanciaTotalPuntoCentral(NumFicPat);
				
			}
			if (turno == 2)
			{
			
				if (casilla_borrar[0] != -1)
				{	
					for (int a = 0; a<16;a++)
					{
						if (casilla_borrar[a] != -1)
						{
							quitaficha = tablero.casillas[casilla_borrar[a]].numficha;
							quitacasilla = tablero.casillas[casilla_borrar[a]].numcasilla;

							//Nuevo
							tablero.casillas[quitacasilla] = new Casilla(quitacasilla);
							///////////
							tablero.casillas[casilla_borrar[a]].quitarFichaEnSeleccionada();
							
							//desactivamos la ficha que se elimina del tablero
							tablero.jugadores[0].fichas[quitaficha].desactivarFicha();
							int cont = 0;
							for (int i=0;i<12;i++)
								if (tablero.jugadores[0].fichas[i].activo)
								{
									cont++;
									System.out.println(i);
		    					}
							System.out.println("Numero fichas activas despues de mover yo y comer_ " + cont + " " + quitacasilla + " " + quitaficha);
							//tablero.jugadores[numjug - 2].numFichaTotal--;
							NumFicPat--;	
						}
					}
				}
				
				tablero.casillas[numcascan] = new Casilla (numficha,turno,numcascan);
				
		        //Actualizamos los valores de la casilla candidata 		
				tablero.casillas[numcascan].colocarFichaEnCandidata(numficha, numjug);
				
				//Actualizamos las caracteristicas de la casilla hacia la que se mueve la ficha 		
				tablero.jugadores[numjug - 1].fichas[numficha].actualizarCasillaFicha(numcascan);
				
				//Actualizamos los valores de la casilla seleccionada 		
				tablero.casillas[numcasilla] = new Casilla (numcasilla);
				
				//Actualizamos los valores de la casilla seleccionada 		
				tablero.casillas[numcasilla].quitarFichaEnSeleccionada();
			/*
		        for (int i=0; i<tablero.casillas.length;i++)
				{
					System.out.print("C=" + tablero.casillas[i].numcasilla + ",F=" + tablero.casillas[i].numficha + ",J= " + tablero.casillas[i].numjugador + " ");
				}
				System.out.println("");
		        	*/	
				//update(getGraphics());
			
				//Actualizamos las caraceristicas del movimiento realizado por el jugador que mueva		
				tablero.jugadores[numjug - 1].movimientos ++; 
				tablero.jugadores[numjug - 1].ultimaFicha = numficha;
				tablero.jugadores[numjug - 1].ultimaCasilla = numcasilla;
				update(getGraphics());

				//tablero.jugadores[numjug - 1].calcularDistanciaTotalPuntoCentral(1);//siempre hay un zorro
				
			//	tablero.jugadores[numjug - 1].calcularDistanciaTotalFichasColocadas(); //Actualiza el valor de distanciaTotal
	
			}
			turno = actualizaTurno(); //Cada vez que se mueva se actualiza el turno
			lTurno.setText("Turno: Jugador "+turno);
			
			if (turno == 1)
			{
				lAviso.setText("Se ha movido la ficha "+numficha%1+" del jugador "+
						numjug+" (ZORRAS) a la casilla "+numCasillaCandidata);
	
			}
			else
			{
				lAviso.setText("Se ha movido la ficha "+numficha%tablero.jugadores[numjug - 1].numFichaTotal+" del jugador "+
						numjug+" (OCAS) a la casilla "+numCasillaCandidata);
	
			}
			
			actualizaPanelTurnos(); //Para que resalte el panelInfo del jugador que posee el turno
			
			if(compruebaGanador() != 0)// || numMovimientos == totalMovimientos)
			{
				detenerJuego = true;
				numMovimientos=0;
				return;
			}
			if(!detenerJuego && tablero.jugadores[turno-1].esPC)
			{
				mover_pc();
			}	
		}
		else if (tipotabl == 2 || tipotabl == 6)
		{
			int numficha = tablero.casillas[numCasillaSeleccionada].numficha;
			int numcasilla = tablero.casillas[numCasillaSeleccionada].numcasilla;
			int numcascan = tablero.casillas[numCasillaCandidata].numcasilla;
			int quitaficha = -1;
			int quitacasilla = -1;
			
			int numjug = turno;
			
			numMovimientos++;
			lNumMovimientos.setText("Nº Movientos: " + numMovimientos);
			//Actualizamos los valores de la casilla candidata 		
			//tablero.casillas[numCasillaCandidata].colocarFichaEnCandidata(numficha, numjug);
			if (turno==1)
			{
				tablero.casillas[numcascan] = new Casilla (numficha,turno,numcascan);
				
		        //Actualizamos los valores de la casilla candidata 		
				tablero.casillas[numcascan].colocarFichaEnCandidata(numficha, numjug);
				
				//Actualizamos las caracteristicas de la casilla hacia la que se mueve la ficha 		
				tablero.jugadores[numjug - 1].fichas[numficha].actualizarCasillaFicha(numcascan);
				
				//Actualizamos los valores de la casilla seleccionada 		
				tablero.casillas[numcasilla] = new Casilla (numcasilla);
				
				//Actualizamos los valores de la casilla seleccionada 		
				tablero.casillas[numcasilla].quitarFichaEnSeleccionada();
				
				update(getGraphics());
						
				//Actualizamos las caraceristicas del movimiento realizado por el jugador que mueva		
				tablero.jugadores[numjug - 1].movimientos ++; 
				tablero.jugadores[numjug - 1].ultimaFicha = numficha;
				tablero.jugadores[numjug - 1].ultimaCasilla = numcasilla;
				
				//tablero.jugadores[numjug - 1].calcularDistanciaTotalPuntoCentral(NumFicPat);
			}
			if (turno == 2)
			{
				if (casilla_borrar[0] != -1)
				{	
					for (int a = 0; a<16;a++)
					{
						if (casilla_borrar[a] != -1)
						{
							quitaficha = tablero.casillas[casilla_borrar[a]].numficha;
							quitacasilla = tablero.casillas[casilla_borrar[a]].numcasilla;
							
							//Nuevo
							tablero.casillas[quitacasilla] = new Casilla(quitacasilla);
							///////////
							tablero.casillas[casilla_borrar[a]].quitarFichaEnSeleccionada();
							
							//desactivamos la ficha que se elimina del tablero
							tablero.jugadores[0].fichas[quitaficha].desactivarFicha();
							int cont = 0;
							for (int i=0;i<21;i++)
								if (tablero.jugadores[0].fichas[i].activo)
								{
									cont++;
									System.out.println(i);
		    					}
							System.out.println("Numero fichas activas despues de mover yo y comer_ " + cont + " " + quitacasilla + " " + quitaficha);
							//tablero.jugadores[numjug - 2].numFichaTotal--;
							NumFicPat--;
						}
					}
				}
				
				tablero.casillas[numcascan] = new Casilla (numficha,turno,numcascan);
				
		        //Actualizamos los valores de la casilla candidata 		
				tablero.casillas[numcascan].colocarFichaEnCandidata(numficha, numjug);
				
				//Actualizamos las caracteristicas de la casilla hacia la que se mueve la ficha 		
				tablero.jugadores[numjug - 1].fichas[numficha].actualizarCasillaFicha(numcascan);
				
				//Actualizamos los valores de la casilla seleccionada 		
				tablero.casillas[numcasilla] = new Casilla (numcasilla);
				
				//Actualizamos los valores de la casilla seleccionada 		
				tablero.casillas[numcasilla].quitarFichaEnSeleccionada();
			/*
		        for (int i=0; i<tablero.casillas.length;i++)
				{
					System.out.print("C=" + tablero.casillas[i].numcasilla + ",F=" + tablero.casillas[i].numficha + ",J= " + tablero.casillas[i].numjugador + " ");
				}
				System.out.println("");			
				//update(getGraphics());
				*/
				//Actualizamos las caraceristicas del movimiento realizado por el jugador que mueva		
				tablero.jugadores[numjug - 1].movimientos ++; 
				tablero.jugadores[numjug - 1].ultimaFicha = numficha;
				tablero.jugadores[numjug - 1].ultimaCasilla = numcasilla;
				update(getGraphics());

				//tablero.jugadores[numjug - 1].calcularDistanciaTotalPuntoCentral(1);//siempre hay un zorro
				
			}
			
			turno = actualizaTurno(); //Cada vez que se mueva se actualiza el turno
			lTurno.setText("Turno: Jugador "+turno);
			
			if (turno == 1)
			{
				
				lAviso.setText("Se ha movido la ficha "+numficha%1+" del jugador "+
						numjug+" (ZORRAS) a la casilla "+numCasillaCandidata);

			}
			else
			{
				lAviso.setText("Se ha movido la ficha "+numficha%tablero.jugadores[numjug - 1].numFichaTotal+" del jugador "+
						numjug+" (OCAS) a la casilla "+numCasillaCandidata);

			}
			
			
			
			actualizaPanelTurnos(); //Para que resalte el panelInfo del jugador que posee el turno
			
			if(compruebaGanador() != 0)// || numMovimientos == totalMovimientos)
			{
				detenerJuego = true;
				numMovimientos=0;
				return;
			}
			System.out.println("FIN MOVERRRRRR");
			
			if(!detenerJuego && tablero.jugadores[turno-1].esPC)
			{
				mover_pc();
			}
		}
		else if (tipotabl == 3 || tipotabl == 5)
		{
			int numficha = tablero.casillas[numCasillaSeleccionada].numficha;
			int numcasilla = tablero.casillas[numCasillaSeleccionada].numcasilla;
			int numcascan = tablero.casillas[numCasillaCandidata].numcasilla;
			int quitaficha = -1;
			int quitacasilla = -1;
			
			int numjug = turno;
			
			numMovimientos++;
			lNumMovimientos.setText("Nº Movimientos: " + numMovimientos);

			if (turno==1)
			{
				 	tablero.casillas[numcascan] = new Casilla (numficha,turno,numcascan);
					
			        //Actualizamos los valores de la casilla candidata 		
					tablero.casillas[numcascan].colocarFichaEnCandidata(numficha, numjug);
					
					//Actualizamos las caracteristicas de la casilla hacia la que se mueve la ficha 		
					tablero.jugadores[numjug - 1].fichas[numficha].actualizarCasillaFicha(numcascan);
					
					//Actualizamos los valores de la casilla seleccionada 		
					tablero.casillas[numcasilla] = new Casilla (numcasilla);
					
					//Actualizamos los valores de la casilla seleccionada 		
					tablero.casillas[numcasilla].quitarFichaEnSeleccionada();
			       
				//update(getGraphics());
						
				//Actualizamos las caraceristicas del movimiento realizado por el jugador que mueva		
				tablero.jugadores[numjug - 1].movimientos ++; 
				tablero.jugadores[numjug - 1].ultimaFicha = numficha;
				tablero.jugadores[numjug - 1].ultimaCasilla = numcasilla;
				update(getGraphics());
				
				//tablero.jugadores[numjug - 1].calcularDistanciaTotalPuntoCentral(NumFicPat);
			}
			if (turno == 2)
			{
				if (casilla_borrar[0] != -1)
				{	
					for (int a = 0; a<16;a++)
					{
						if (casilla_borrar[a] != -1)
						{
							quitaficha = tablero.casillas[casilla_borrar[a]].numficha;
							quitacasilla = tablero.casillas[casilla_borrar[a]].numcasilla;

							//Nuevo
							tablero.casillas[quitacasilla] = new Casilla(quitacasilla);
							///////////
							tablero.casillas[casilla_borrar[a]].quitarFichaEnSeleccionada();
							
							//desactivamos la ficha que se elimina del tablero
							tablero.jugadores[0].fichas[quitaficha].desactivarFicha();
							int cont = 0;
							for (int i=0;i<13;i++)
								if (tablero.jugadores[0].fichas[i].activo)
								{
									cont++;
									System.out.println(i);
		    					}
							System.out.println("Numero fichas activas despues de mover yo y comer_ " + cont + " " + quitacasilla + " " + quitaficha);
							//tablero.jugadores[numjug - 2].numFichaTotal--;
							NumFicPat--;
							
						}
					}
				
				}
				
				tablero.casillas[numcascan] = new Casilla (numficha,turno,numcascan);
				
		        //Actualizamos los valores de la casilla candidata 		
				tablero.casillas[numcascan].colocarFichaEnCandidata(numficha, numjug);
				
				//Actualizamos las caracteristicas de la casilla hacia la que se mueve la ficha 		
				tablero.jugadores[numjug - 1].fichas[numficha].actualizarCasillaFicha(numcascan);
				
				//Actualizamos los valores de la casilla seleccionada 		
				tablero.casillas[numcasilla] = new Casilla (numcasilla);
				
				//Actualizamos los valores de la casilla seleccionada 		
				tablero.casillas[numcasilla].quitarFichaEnSeleccionada();
			/*
		        for (int i=0; i<tablero.casillas.length;i++)
				{
					System.out.print("C=" + tablero.casillas[i].numcasilla + ",F=" + tablero.casillas[i].numficha + ",J= " + tablero.casillas[i].numjugador + " ");
				}
				System.out.println("");
		        		
				//update(getGraphics());
				*/
				//Actualizamos las caraceristicas del movimiento realizado por el jugador que mueva		
				tablero.jugadores[numjug - 1].movimientos ++; 
				tablero.jugadores[numjug - 1].ultimaFicha = numficha;
				tablero.jugadores[numjug - 1].ultimaCasilla = numcasilla;
				update(getGraphics());

				//tablero.jugadores[numjug - 1].calcularDistanciaTotalPuntoCentral(1);//siempre hay un zorro
				
			}
			

			turno = actualizaTurno(); //Cada vez que se mueva se actualiza el turno
			lTurno.setText("Turno: Jugador "+turno);
			
			if (turno == 1)
			{
				lAviso.setText("Se ha movido la ficha "+numficha%1+" del jugador "+
						numjug+" (ZORRAS) a la casilla "+numCasillaCandidata);

			}
			else
			{
				lAviso.setText("Se ha movido la ficha "+numficha%tablero.jugadores[numjug - 1].numFichaTotal+" del jugador "+
						numjug+" (OCAS) a la casilla "+numCasillaCandidata);

			}
			
			actualizaPanelTurnos(); //Para que resalte el panelInfo del jugador que posee el turno
			
			if(compruebaGanador() != 0)// || numMovimientos == totalMovimientos)
			{
				detenerJuego = true;
				numMovimientos=0;
				return;
			}
			System.out.println("FIN MOVERRRRRR");
			
			if(!detenerJuego && tablero.jugadores[turno-1].esPC)
			{
				mover_pc();
			}
		}
	}
	
	//Dada una posicion (i,j) devuelve su casilla asociada
	public int asociaCasilla(int i, int j)
	{
		return ((5 * j) + i);
	}
	
	public int XasociaCasilla (int i, int j)
	{
		return ((7 * j) + i);
	}
	
	public int actualizaTurno() 
	{
		int resultado = 0;
		
		if (numjugadores == 2)
		{
			if (turno == 1)
			{
				resultado = 2;
			}
			else
			{
				resultado = 1;
			}
		}
		
		return resultado;
	}

	public void actualizaPanelTurnos() //Para sobresaltar el panelInfo del que tiene el turno y tapar los que no
	{        
		 //if (numjugadores == 2)
		//{
			if (turno == 1)
			{
				botonJugador1.setEnabled(true);
				botonJugador2.setEnabled(false);
			
			}
			else if (turno == 2)
			{
				botonJugador1.setEnabled(false);
				botonJugador2.setEnabled(true);

			}
		//}
	}
		
	public void inicializaSaltos() //saltos[0] no se inicializa porque siempre contendra la casillaSeleccionada
	{
		for(int i=1; i<16; i++)
		{
			saltos[i] = -1;
			sal_borra[i] = -1;
			vector_aux[i]=-1;
		}
		numsalto = 0;
	}
	
	public int compruebaGanador()
	{
		//Devuelve el numjugador del ganador o devuelve 0 si no hay ganador
		int result = 0;
		int numjug = turno;
		if (tipotabl == 1)
		{
		if (turno == 1)
		{
			if (NumFicPat<11)// || numMovimientos == 2)
			{
				result = 2;
			}
			
		}
		
		
		if (tablero.casillas[0].numjugador == 2 && tablero.casillas[1].ocupado && tablero.casillas[2].ocupado && tablero.casillas[5].ocupado && tablero.casillas[6].ocupado && tablero.casillas[10].ocupado && tablero.casillas[12].ocupado
			||
			tablero.casillas[1].numjugador == 2 && tablero.casillas[0].ocupado && tablero.casillas[2].ocupado && tablero.casillas[3].ocupado && tablero.casillas[5].ocupado && tablero.casillas[6].ocupado && tablero.casillas[7].ocupado && tablero.casillas[11].ocupado && tablero.casillas[13].ocupado			
		    ||
			tablero.casillas[2].numjugador == 2 && tablero.casillas[1].ocupado && tablero.casillas[3].ocupado && tablero.casillas[6].ocupado && tablero.casillas[7].ocupado && tablero.casillas[8].ocupado && tablero.casillas[10].ocupado && tablero.casillas[12].ocupado && tablero.casillas[14].ocupado && tablero.casillas[4].ocupado		
			||
			tablero.casillas[3].numjugador == 2 && tablero.casillas[2].ocupado && tablero.casillas[4].ocupado && tablero.casillas[7].ocupado && tablero.casillas[8].ocupado && tablero.casillas[9].ocupado && tablero.casillas[11].ocupado && tablero.casillas[13].ocupado
			||
			tablero.casillas[4].numjugador == 2 && tablero.casillas[2].ocupado && tablero.casillas[3].ocupado && tablero.casillas[8].ocupado && tablero.casillas[9].ocupado && tablero.casillas[12].ocupado && tablero.casillas[14].ocupado
			||
			tablero.casillas[5].numjugador == 2 && tablero.casillas[0].ocupado && tablero.casillas[1].ocupado && tablero.casillas[6].ocupado && tablero.casillas[11].ocupado && tablero.casillas[10].ocupado && tablero.casillas[15].ocupado && tablero.casillas[17].ocupado && tablero.casillas[7].ocupado			
			||
			tablero.casillas[6].numjugador == 2 && tablero.casillas[0].ocupado && tablero.casillas[1].ocupado && tablero.casillas[2].ocupado && tablero.casillas[5].ocupado && tablero.casillas[7].ocupado && tablero.casillas[10].ocupado && tablero.casillas[11].ocupado && tablero.casillas[12].ocupado && tablero.casillas[16].ocupado && tablero.casillas[18].ocupado && tablero.casillas[8].ocupado			
			||
			tablero.casillas[7].numjugador == 2 && tablero.casillas[1].ocupado && tablero.casillas[2].ocupado && tablero.casillas[3].ocupado && tablero.casillas[6].ocupado && tablero.casillas[8].ocupado && tablero.casillas[11].ocupado && tablero.casillas[12].ocupado && tablero.casillas[13].ocupado && tablero.casillas[5].ocupado && tablero.casillas[15].ocupado && tablero.casillas[17].ocupado && tablero.casillas[19].ocupado && tablero.casillas[9].ocupado			
			||
			tablero.casillas[8].numjugador == 2 && tablero.casillas[2].ocupado && tablero.casillas[3].ocupado && tablero.casillas[4].ocupado && tablero.casillas[7].ocupado && tablero.casillas[9].ocupado && tablero.casillas[12].ocupado && tablero.casillas[13].ocupado && tablero.casillas[14].ocupado && tablero.casillas[6].ocupado && tablero.casillas[16].ocupado && tablero.casillas[18].ocupado
			||
			tablero.casillas[9].numjugador == 2 && tablero.casillas[3].ocupado && tablero.casillas[4].ocupado && tablero.casillas[8].ocupado && tablero.casillas[13].ocupado && tablero.casillas[14].ocupado && tablero.casillas[7].ocupado && tablero.casillas[17].ocupado && tablero.casillas[19].ocupado			
			||
			tablero.casillas[10].numjugador == 2 && tablero.casillas[5].ocupado && tablero.casillas[6].ocupado && tablero.casillas[11].ocupado && tablero.casillas[16].ocupado && tablero.casillas[15].ocupado && tablero.casillas[0].ocupado && tablero.casillas[2].ocupado && tablero.casillas[12].ocupado && tablero.casillas[22].ocupado && tablero.casillas[20].ocupado			
			||
			tablero.casillas[11].numjugador == 2 && tablero.casillas[5].ocupado && tablero.casillas[6].ocupado && tablero.casillas[7].ocupado && tablero.casillas[10].ocupado && tablero.casillas[12].ocupado && tablero.casillas[15].ocupado && tablero.casillas[16].ocupado && tablero.casillas[17].ocupado && tablero.casillas[1].ocupado && tablero.casillas[3].ocupado && tablero.casillas[13].ocupado && tablero.casillas[23].ocupado && tablero.casillas[21].ocupado			
			||
			tablero.casillas[12].numjugador == 2 && tablero.casillas[6].ocupado && tablero.casillas[7].ocupado && tablero.casillas[8].ocupado && tablero.casillas[11].ocupado && tablero.casillas[13].ocupado && tablero.casillas[16].ocupado && tablero.casillas[17].ocupado && tablero.casillas[18].ocupado && tablero.casillas[0].ocupado && tablero.casillas[2].ocupado && tablero.casillas[4].ocupado && tablero.casillas[10].ocupado && tablero.casillas[14].ocupado && tablero.casillas[20].ocupado && tablero.casillas[22].ocupado && tablero.casillas[24].ocupado			
			||
			tablero.casillas[13].numjugador == 2 && tablero.casillas[7].ocupado && tablero.casillas[8].ocupado && tablero.casillas[9].ocupado && tablero.casillas[12].ocupado && tablero.casillas[14].ocupado && tablero.casillas[17].ocupado && tablero.casillas[18].ocupado && tablero.casillas[19].ocupado && tablero.casillas[1].ocupado && tablero.casillas[3].ocupado && tablero.casillas[11].ocupado && tablero.casillas[23].ocupado && tablero.casillas[21].ocupado			
			||
			tablero.casillas[14].numjugador == 2 && tablero.casillas[8].ocupado && tablero.casillas[9].ocupado && tablero.casillas[13].ocupado && tablero.casillas[18].ocupado && tablero.casillas[19].ocupado && tablero.casillas[4].ocupado && tablero.casillas[2].ocupado && tablero.casillas[12].ocupado && tablero.casillas[22].ocupado && tablero.casillas[24].ocupado			
			||
			tablero.casillas[15].numjugador == 2 && tablero.casillas[10].ocupado && tablero.casillas[11].ocupado && tablero.casillas[16].ocupado && tablero.casillas[21].ocupado && tablero.casillas[20].ocupado && tablero.casillas[5].ocupado && tablero.casillas[7].ocupado && tablero.casillas[17].ocupado			
			||
			tablero.casillas[16].numjugador == 2 && tablero.casillas[10].ocupado && tablero.casillas[11].ocupado && tablero.casillas[12].ocupado && tablero.casillas[15].ocupado && tablero.casillas[17].ocupado && tablero.casillas[20].ocupado && tablero.casillas[21].ocupado && tablero.casillas[22].ocupado && tablero.casillas[6].ocupado && tablero.casillas[8].ocupado && tablero.casillas[18].ocupado			
			||
			tablero.casillas[17].numjugador == 2 && tablero.casillas[11].ocupado && tablero.casillas[12].ocupado && tablero.casillas[13].ocupado && tablero.casillas[16].ocupado && tablero.casillas[18].ocupado && tablero.casillas[21].ocupado && tablero.casillas[22].ocupado && tablero.casillas[23].ocupado && tablero.casillas[5].ocupado && tablero.casillas[15].ocupado && tablero.casillas[7].ocupado && tablero.casillas[19].ocupado && tablero.casillas[9].ocupado			
			||
			tablero.casillas[18].numjugador == 2 && tablero.casillas[12].ocupado && tablero.casillas[13].ocupado && tablero.casillas[14].ocupado && tablero.casillas[17].ocupado && tablero.casillas[19].ocupado && tablero.casillas[22].ocupado && tablero.casillas[23].ocupado && tablero.casillas[24].ocupado && tablero.casillas[6].ocupado && tablero.casillas[16].ocupado && tablero.casillas[8].ocupado
			||
			tablero.casillas[19].numjugador == 2 && tablero.casillas[13].ocupado && tablero.casillas[14].ocupado && tablero.casillas[18].ocupado && tablero.casillas[23].ocupado && tablero.casillas[24].ocupado && tablero.casillas[7].ocupado && tablero.casillas[17].ocupado && tablero.casillas[9].ocupado			
			||
			tablero.casillas[20].numjugador == 2 && tablero.casillas[21].ocupado && tablero.casillas[22].ocupado && tablero.casillas[15].ocupado && tablero.casillas[16].ocupado && tablero.casillas[10].ocupado && tablero.casillas[12].ocupado
			||
			tablero.casillas[21].numjugador == 2 && tablero.casillas[20].ocupado && tablero.casillas[22].ocupado && tablero.casillas[23].ocupado && tablero.casillas[15].ocupado && tablero.casillas[16].ocupado && tablero.casillas[17].ocupado && tablero.casillas[11].ocupado && tablero.casillas[13].ocupado			
		    ||
			tablero.casillas[22].numjugador == 2 && tablero.casillas[21].ocupado && tablero.casillas[23].ocupado && tablero.casillas[16].ocupado && tablero.casillas[17].ocupado && tablero.casillas[18].ocupado && tablero.casillas[10].ocupado && tablero.casillas[12].ocupado && tablero.casillas[14].ocupado && tablero.casillas[24].ocupado			
			||
			tablero.casillas[23].numjugador == 2 && tablero.casillas[22].ocupado && tablero.casillas[24].ocupado && tablero.casillas[17].ocupado && tablero.casillas[18].ocupado && tablero.casillas[19].ocupado && tablero.casillas[11].ocupado && tablero.casillas[13].ocupado
			||
			tablero.casillas[24].numjugador == 2 && tablero.casillas[22].ocupado && tablero.casillas[23].ocupado && tablero.casillas[18].ocupado && tablero.casillas[19].ocupado && tablero.casillas[12].ocupado && tablero.casillas[14].ocupado
		)
		{
			result = 1;
		}
		
		}
		else if (tipotabl == 2)
		{
			if (turno == 1)
			{
				//if (tablero.jugadores[numjug - 1].numFichaTotal<9)
				if (NumFicPat<15)
				{
					result = 2;
				}
			}
			if (tablero.casillas[0].numjugador == 2 && tablero.casillas[1].ocupado && tablero.casillas[7].ocupado && tablero.casillas[8].ocupado && tablero.casillas[2].ocupado && tablero.casillas[16].ocupado && tablero.casillas[14].ocupado
					||
					tablero.casillas[1].numjugador == 2 && tablero.casillas[0].ocupado && tablero.casillas[2].ocupado && tablero.casillas[3].ocupado && tablero.casillas[7].ocupado && tablero.casillas[8].ocupado && tablero.casillas[9].ocupado && tablero.casillas[15].ocupado && tablero.casillas[17].ocupado			
				    ||
					tablero.casillas[2].numjugador == 2 && tablero.casillas[1].ocupado && tablero.casillas[3].ocupado && tablero.casillas[8].ocupado && tablero.casillas[9].ocupado && tablero.casillas[10].ocupado && tablero.casillas[0].ocupado && tablero.casillas[4].ocupado && tablero.casillas[14].ocupado && tablero.casillas[18].ocupado		
					||
					tablero.casillas[3].numjugador == 2 && tablero.casillas[2].ocupado && tablero.casillas[4].ocupado && tablero.casillas[9].ocupado && tablero.casillas[10].ocupado && tablero.casillas[11].ocupado && tablero.casillas[1].ocupado && tablero.casillas[5].ocupado && tablero.casillas[15].ocupado && tablero.casillas[17].ocupado && tablero.casillas[19].ocupado
					||
					tablero.casillas[4].numjugador == 2 && tablero.casillas[3].ocupado && tablero.casillas[5].ocupado && tablero.casillas[10].ocupado && tablero.casillas[11].ocupado && tablero.casillas[12].ocupado && tablero.casillas[2].ocupado && tablero.casillas[6].ocupado && tablero.casillas[16].ocupado && tablero.casillas[18].ocupado && tablero.casillas[20].ocupado
					||
					tablero.casillas[5].numjugador == 2 && tablero.casillas[4].ocupado && tablero.casillas[6].ocupado && tablero.casillas[11].ocupado && tablero.casillas[12].ocupado && tablero.casillas[13].ocupado && tablero.casillas[3].ocupado && tablero.casillas[17].ocupado && tablero.casillas[19].ocupado			
					||
					tablero.casillas[6].numjugador == 2 && tablero.casillas[5].ocupado && tablero.casillas[12].ocupado && tablero.casillas[13].ocupado && tablero.casillas[4].ocupado && tablero.casillas[18].ocupado && tablero.casillas[20].ocupado 
					||
					tablero.casillas[7].numjugador == 2 && tablero.casillas[0].ocupado && tablero.casillas[1].ocupado && tablero.casillas[8].ocupado && tablero.casillas[15].ocupado && tablero.casillas[14].ocupado && tablero.casillas[9].ocupado && tablero.casillas[23].ocupado && tablero.casillas[21].ocupado 
					||
					tablero.casillas[8].numjugador == 2 && tablero.casillas[0].ocupado && tablero.casillas[1].ocupado && tablero.casillas[2].ocupado && tablero.casillas[7].ocupado && tablero.casillas[9].ocupado && tablero.casillas[14].ocupado && tablero.casillas[15].ocupado && tablero.casillas[16].ocupado && tablero.casillas[10].ocupado && tablero.casillas[24].ocupado && tablero.casillas[22].ocupado
					||
					tablero.casillas[9].numjugador == 2 && tablero.casillas[1].ocupado && tablero.casillas[2].ocupado && tablero.casillas[3].ocupado && tablero.casillas[8].ocupado && tablero.casillas[10].ocupado && tablero.casillas[15].ocupado && tablero.casillas[16].ocupado && tablero.casillas[17].ocupado	&& tablero.casillas[7].ocupado	&& tablero.casillas[11].ocupado	&& tablero.casillas[21].ocupado && tablero.casillas[23].ocupado && tablero.casillas[25].ocupado
					||
					tablero.casillas[10].numjugador == 2 && tablero.casillas[2].ocupado && tablero.casillas[3].ocupado && tablero.casillas[4].ocupado && tablero.casillas[9].ocupado && tablero.casillas[11].ocupado && tablero.casillas[16].ocupado && tablero.casillas[17].ocupado && tablero.casillas[18].ocupado && tablero.casillas[8].ocupado && tablero.casillas[12].ocupado	&& tablero.casillas[22].ocupado	&& tablero.casillas[24].ocupado	&& tablero.casillas[26].ocupado
					||
					tablero.casillas[11].numjugador == 2 && tablero.casillas[3].ocupado && tablero.casillas[4].ocupado && tablero.casillas[5].ocupado && tablero.casillas[10].ocupado && tablero.casillas[12].ocupado && tablero.casillas[17].ocupado && tablero.casillas[18].ocupado && tablero.casillas[19].ocupado && tablero.casillas[9].ocupado && tablero.casillas[13].ocupado && tablero.casillas[23].ocupado && tablero.casillas[25].ocupado && tablero.casillas[27].ocupado			
					||
					tablero.casillas[12].numjugador == 2 && tablero.casillas[4].ocupado && tablero.casillas[5].ocupado && tablero.casillas[6].ocupado && tablero.casillas[11].ocupado && tablero.casillas[13].ocupado && tablero.casillas[18].ocupado && tablero.casillas[19].ocupado && tablero.casillas[20].ocupado && tablero.casillas[10].ocupado && tablero.casillas[24].ocupado && tablero.casillas[26].ocupado			
					||
					tablero.casillas[13].numjugador == 2 && tablero.casillas[5].ocupado && tablero.casillas[6].ocupado && tablero.casillas[12].ocupado && tablero.casillas[19].ocupado && tablero.casillas[20].ocupado && tablero.casillas[11].ocupado && tablero.casillas[25].ocupado && tablero.casillas[27].ocupado			
					||
					tablero.casillas[14].numjugador == 2 && tablero.casillas[7].ocupado && tablero.casillas[8].ocupado && tablero.casillas[15].ocupado && tablero.casillas[21].ocupado && tablero.casillas[22].ocupado && tablero.casillas[0].ocupado && tablero.casillas[2].ocupado && tablero.casillas[16].ocupado && tablero.casillas[30].ocupado && tablero.casillas[28].ocupado			
					||
					tablero.casillas[15].numjugador == 2 && tablero.casillas[7].ocupado && tablero.casillas[8].ocupado && tablero.casillas[9].ocupado && tablero.casillas[14].ocupado && tablero.casillas[16].ocupado && tablero.casillas[21].ocupado && tablero.casillas[22].ocupado && tablero.casillas[23].ocupado && tablero.casillas[1].ocupado && tablero.casillas[3].ocupado && tablero.casillas[17].ocupado	&& tablero.casillas[29].ocupado	&& tablero.casillas[31].ocupado	
					||
					tablero.casillas[16].numjugador == 2 && tablero.casillas[8].ocupado && tablero.casillas[9].ocupado && tablero.casillas[10].ocupado && tablero.casillas[15].ocupado && tablero.casillas[17].ocupado && tablero.casillas[22].ocupado && tablero.casillas[23].ocupado && tablero.casillas[24].ocupado && tablero.casillas[0].ocupado && tablero.casillas[2].ocupado && tablero.casillas[4].ocupado	&& tablero.casillas[14].ocupado	&& tablero.casillas[18].ocupado	&& tablero.casillas[28].ocupado && tablero.casillas[30].ocupado && tablero.casillas[32].ocupado
					||
					tablero.casillas[17].numjugador == 2 && tablero.casillas[9].ocupado && tablero.casillas[10].ocupado && tablero.casillas[11].ocupado && tablero.casillas[16].ocupado && tablero.casillas[18].ocupado && tablero.casillas[23].ocupado && tablero.casillas[24].ocupado && tablero.casillas[25].ocupado && tablero.casillas[1].ocupado && tablero.casillas[3].ocupado && tablero.casillas[5].ocupado && tablero.casillas[15].ocupado && tablero.casillas[19].ocupado && tablero.casillas[29].ocupado && tablero.casillas[31].ocupado && tablero.casillas[33].ocupado			
					||
					tablero.casillas[18].numjugador == 2 && tablero.casillas[10].ocupado && tablero.casillas[11].ocupado && tablero.casillas[12].ocupado && tablero.casillas[17].ocupado && tablero.casillas[19].ocupado && tablero.casillas[24].ocupado && tablero.casillas[25].ocupado && tablero.casillas[26].ocupado && tablero.casillas[2].ocupado && tablero.casillas[4].ocupado && tablero.casillas[6].ocupado && tablero.casillas[16].ocupado && tablero.casillas[20].ocupado && tablero.casillas[30].ocupado && tablero.casillas[32].ocupado && tablero.casillas[34].ocupado
					||
					tablero.casillas[19].numjugador == 2 && tablero.casillas[11].ocupado && tablero.casillas[12].ocupado && tablero.casillas[13].ocupado && tablero.casillas[18].ocupado && tablero.casillas[20].ocupado && tablero.casillas[25].ocupado && tablero.casillas[26].ocupado && tablero.casillas[27].ocupado && tablero.casillas[3].ocupado	&& tablero.casillas[5].ocupado && tablero.casillas[17].ocupado && tablero.casillas[31].ocupado && tablero.casillas[33].ocupado	
					||
					tablero.casillas[20].numjugador == 2 && tablero.casillas[12].ocupado && tablero.casillas[13].ocupado && tablero.casillas[19].ocupado && tablero.casillas[26].ocupado && tablero.casillas[27].ocupado && tablero.casillas[4].ocupado && tablero.casillas[18].ocupado && tablero.casillas[32].ocupado && tablero.casillas[34].ocupado
					||
					tablero.casillas[21].numjugador == 2 && tablero.casillas[14].ocupado && tablero.casillas[15].ocupado && tablero.casillas[22].ocupado && tablero.casillas[28].ocupado && tablero.casillas[29].ocupado && tablero.casillas[7].ocupado && tablero.casillas[9].ocupado && tablero.casillas[23].ocupado && tablero.casillas[37].ocupado && tablero.casillas[35].ocupado			
				    ||
					tablero.casillas[22].numjugador == 2 && tablero.casillas[14].ocupado && tablero.casillas[15].ocupado && tablero.casillas[16].ocupado && tablero.casillas[21].ocupado && tablero.casillas[23].ocupado && tablero.casillas[28].ocupado && tablero.casillas[29].ocupado && tablero.casillas[30].ocupado && tablero.casillas[8].ocupado	&& tablero.casillas[10].ocupado	&& tablero.casillas[24].ocupado	&& tablero.casillas[38].ocupado && tablero.casillas[36].ocupado
					||
					tablero.casillas[23].numjugador == 2 && tablero.casillas[15].ocupado && tablero.casillas[16].ocupado && tablero.casillas[17].ocupado && tablero.casillas[22].ocupado && tablero.casillas[24].ocupado && tablero.casillas[29].ocupado && tablero.casillas[30].ocupado && tablero.casillas[31].ocupado && tablero.casillas[7].ocupado && tablero.casillas[9].ocupado && tablero.casillas[11].ocupado && tablero.casillas[21].ocupado && tablero.casillas[25].ocupado && tablero.casillas[35].ocupado && tablero.casillas[37].ocupado && tablero.casillas[39].ocupado
					||
					tablero.casillas[24].numjugador == 2 && tablero.casillas[16].ocupado && tablero.casillas[17].ocupado && tablero.casillas[18].ocupado && tablero.casillas[23].ocupado && tablero.casillas[25].ocupado && tablero.casillas[30].ocupado && tablero.casillas[31].ocupado && tablero.casillas[32].ocupado && tablero.casillas[8].ocupado && tablero.casillas[10].ocupado && tablero.casillas[12].ocupado && tablero.casillas[22].ocupado && tablero.casillas[26].ocupado && tablero.casillas[36].ocupado && tablero.casillas[38].ocupado && tablero.casillas[40].ocupado
					||
					tablero.casillas[25].numjugador == 2 && tablero.casillas[17].ocupado && tablero.casillas[18].ocupado && tablero.casillas[19].ocupado && tablero.casillas[24].ocupado && tablero.casillas[26].ocupado && tablero.casillas[31].ocupado && tablero.casillas[32].ocupado && tablero.casillas[33].ocupado && tablero.casillas[9].ocupado && tablero.casillas[11].ocupado && tablero.casillas[13].ocupado && tablero.casillas[23].ocupado && tablero.casillas[27].ocupado && tablero.casillas[37].ocupado && tablero.casillas[39].ocupado && tablero.casillas[41].ocupado
					||
					tablero.casillas[26].numjugador == 2 && tablero.casillas[18].ocupado && tablero.casillas[19].ocupado && tablero.casillas[20].ocupado && tablero.casillas[25].ocupado && tablero.casillas[27].ocupado && tablero.casillas[32].ocupado && tablero.casillas[33].ocupado && tablero.casillas[34].ocupado && tablero.casillas[10].ocupado && tablero.casillas[12].ocupado && tablero.casillas[24].ocupado && tablero.casillas[38].ocupado && tablero.casillas[40].ocupado
					||
					tablero.casillas[27].numjugador == 2 && tablero.casillas[19].ocupado && tablero.casillas[20].ocupado && tablero.casillas[26].ocupado && tablero.casillas[33].ocupado && tablero.casillas[34].ocupado && tablero.casillas[11].ocupado && tablero.casillas[13].ocupado && tablero.casillas[25].ocupado && tablero.casillas[39].ocupado && tablero.casillas[41].ocupado 
					||
					tablero.casillas[28].numjugador == 2 && tablero.casillas[21].ocupado && tablero.casillas[22].ocupado && tablero.casillas[29].ocupado && tablero.casillas[35].ocupado && tablero.casillas[36].ocupado && tablero.casillas[14].ocupado && tablero.casillas[16].ocupado && tablero.casillas[30].ocupado && tablero.casillas[42].ocupado && tablero.casillas[44].ocupado
					||
					tablero.casillas[29].numjugador == 2 && tablero.casillas[21].ocupado && tablero.casillas[22].ocupado && tablero.casillas[23].ocupado && tablero.casillas[28].ocupado && tablero.casillas[30].ocupado && tablero.casillas[35].ocupado && tablero.casillas[36].ocupado && tablero.casillas[37].ocupado && tablero.casillas[15].ocupado && tablero.casillas[17].ocupado && tablero.casillas[31].ocupado && tablero.casillas[43].ocupado && tablero.casillas[45].ocupado
					||
					tablero.casillas[30].numjugador == 2 && tablero.casillas[22].ocupado && tablero.casillas[23].ocupado && tablero.casillas[24].ocupado && tablero.casillas[29].ocupado && tablero.casillas[31].ocupado && tablero.casillas[36].ocupado && tablero.casillas[37].ocupado && tablero.casillas[38].ocupado && tablero.casillas[14].ocupado && tablero.casillas[16].ocupado && tablero.casillas[18].ocupado && tablero.casillas[28].ocupado && tablero.casillas[32].ocupado && tablero.casillas[42].ocupado && tablero.casillas[44].ocupado && tablero.casillas[46].ocupado
					||
					tablero.casillas[31].numjugador == 2 && tablero.casillas[23].ocupado && tablero.casillas[24].ocupado && tablero.casillas[25].ocupado && tablero.casillas[30].ocupado && tablero.casillas[32].ocupado && tablero.casillas[37].ocupado && tablero.casillas[38].ocupado && tablero.casillas[39].ocupado && tablero.casillas[15].ocupado && tablero.casillas[17].ocupado && tablero.casillas[19].ocupado && tablero.casillas[29].ocupado && tablero.casillas[33].ocupado && tablero.casillas[43].ocupado && tablero.casillas[45].ocupado && tablero.casillas[47].ocupado
					||
					tablero.casillas[32].numjugador == 2 && tablero.casillas[24].ocupado && tablero.casillas[25].ocupado && tablero.casillas[26].ocupado && tablero.casillas[31].ocupado && tablero.casillas[33].ocupado && tablero.casillas[38].ocupado && tablero.casillas[39].ocupado && tablero.casillas[40].ocupado && tablero.casillas[16].ocupado && tablero.casillas[18].ocupado && tablero.casillas[20].ocupado && tablero.casillas[30].ocupado && tablero.casillas[34].ocupado && tablero.casillas[44].ocupado && tablero.casillas[46].ocupado && tablero.casillas[48].ocupado
					||
					tablero.casillas[33].numjugador == 2 && tablero.casillas[25].ocupado && tablero.casillas[26].ocupado && tablero.casillas[27].ocupado && tablero.casillas[32].ocupado && tablero.casillas[34].ocupado && tablero.casillas[39].ocupado && tablero.casillas[40].ocupado && tablero.casillas[41].ocupado && tablero.casillas[17].ocupado && tablero.casillas[19].ocupado && tablero.casillas[31].ocupado && tablero.casillas[45].ocupado && tablero.casillas[47].ocupado
					||
					tablero.casillas[34].numjugador == 2 && tablero.casillas[26].ocupado && tablero.casillas[27].ocupado && tablero.casillas[33].ocupado && tablero.casillas[40].ocupado && tablero.casillas[41].ocupado && tablero.casillas[18].ocupado && tablero.casillas[20].ocupado && tablero.casillas[32].ocupado && tablero.casillas[46].ocupado && tablero.casillas[48].ocupado
					||
					tablero.casillas[35].numjugador == 2 && tablero.casillas[28].ocupado && tablero.casillas[29].ocupado && tablero.casillas[36].ocupado && tablero.casillas[42].ocupado && tablero.casillas[43].ocupado && tablero.casillas[21].ocupado && tablero.casillas[23].ocupado && tablero.casillas[37].ocupado
					||
					tablero.casillas[36].numjugador == 2 && tablero.casillas[28].ocupado && tablero.casillas[29].ocupado && tablero.casillas[30].ocupado && tablero.casillas[35].ocupado && tablero.casillas[37].ocupado && tablero.casillas[42].ocupado && tablero.casillas[43].ocupado && tablero.casillas[44].ocupado && tablero.casillas[22].ocupado && tablero.casillas[24].ocupado && tablero.casillas[38].ocupado
					||
					tablero.casillas[37].numjugador == 2 && tablero.casillas[29].ocupado && tablero.casillas[30].ocupado && tablero.casillas[31].ocupado && tablero.casillas[36].ocupado && tablero.casillas[38].ocupado && tablero.casillas[43].ocupado && tablero.casillas[44].ocupado && tablero.casillas[45].ocupado && tablero.casillas[21].ocupado && tablero.casillas[23].ocupado && tablero.casillas[25].ocupado && tablero.casillas[35].ocupado && tablero.casillas[39].ocupado
					||
					tablero.casillas[38].numjugador == 2 && tablero.casillas[30].ocupado && tablero.casillas[31].ocupado && tablero.casillas[32].ocupado && tablero.casillas[37].ocupado && tablero.casillas[39].ocupado && tablero.casillas[44].ocupado && tablero.casillas[45].ocupado && tablero.casillas[46].ocupado && tablero.casillas[22].ocupado && tablero.casillas[24].ocupado && tablero.casillas[26].ocupado && tablero.casillas[36].ocupado && tablero.casillas[40].ocupado
					||
					tablero.casillas[39].numjugador == 2 && tablero.casillas[31].ocupado && tablero.casillas[32].ocupado && tablero.casillas[33].ocupado && tablero.casillas[38].ocupado && tablero.casillas[40].ocupado && tablero.casillas[45].ocupado && tablero.casillas[46].ocupado && tablero.casillas[47].ocupado && tablero.casillas[23].ocupado && tablero.casillas[25].ocupado && tablero.casillas[27].ocupado && tablero.casillas[37].ocupado && tablero.casillas[41].ocupado
					||
					tablero.casillas[40].numjugador == 2 && tablero.casillas[32].ocupado && tablero.casillas[33].ocupado && tablero.casillas[34].ocupado && tablero.casillas[39].ocupado && tablero.casillas[41].ocupado && tablero.casillas[46].ocupado && tablero.casillas[47].ocupado && tablero.casillas[48].ocupado && tablero.casillas[24].ocupado && tablero.casillas[26].ocupado && tablero.casillas[38].ocupado
					||
					tablero.casillas[41].numjugador == 2 && tablero.casillas[33].ocupado && tablero.casillas[34].ocupado && tablero.casillas[40].ocupado && tablero.casillas[47].ocupado && tablero.casillas[48].ocupado && tablero.casillas[25].ocupado && tablero.casillas[27].ocupado && tablero.casillas[39].ocupado
					||
					tablero.casillas[42].numjugador == 2 && tablero.casillas[35].ocupado && tablero.casillas[36].ocupado && tablero.casillas[43].ocupado && tablero.casillas[28].ocupado && tablero.casillas[30].ocupado && tablero.casillas[44].ocupado
					||
					tablero.casillas[43].numjugador == 2 && tablero.casillas[35].ocupado && tablero.casillas[36].ocupado && tablero.casillas[37].ocupado && tablero.casillas[42].ocupado && tablero.casillas[44].ocupado && tablero.casillas[29].ocupado && tablero.casillas[31].ocupado && tablero.casillas[45].ocupado
					||
					tablero.casillas[44].numjugador == 2 && tablero.casillas[36].ocupado && tablero.casillas[37].ocupado && tablero.casillas[38].ocupado && tablero.casillas[43].ocupado && tablero.casillas[45].ocupado && tablero.casillas[28].ocupado && tablero.casillas[30].ocupado && tablero.casillas[32].ocupado && tablero.casillas[42].ocupado && tablero.casillas[46].ocupado
					||
					tablero.casillas[45].numjugador == 2 && tablero.casillas[37].ocupado && tablero.casillas[38].ocupado && tablero.casillas[39].ocupado && tablero.casillas[44].ocupado && tablero.casillas[46].ocupado && tablero.casillas[29].ocupado && tablero.casillas[31].ocupado && tablero.casillas[33].ocupado && tablero.casillas[43].ocupado && tablero.casillas[47].ocupado 
					||
					tablero.casillas[46].numjugador == 2 && tablero.casillas[38].ocupado && tablero.casillas[39].ocupado && tablero.casillas[40].ocupado && tablero.casillas[45].ocupado && tablero.casillas[47].ocupado && tablero.casillas[30].ocupado && tablero.casillas[32].ocupado && tablero.casillas[34].ocupado && tablero.casillas[44].ocupado && tablero.casillas[48].ocupado
					||
					tablero.casillas[47].numjugador == 2 && tablero.casillas[39].ocupado && tablero.casillas[40].ocupado && tablero.casillas[41].ocupado && tablero.casillas[46].ocupado && tablero.casillas[48].ocupado && tablero.casillas[31].ocupado && tablero.casillas[33].ocupado && tablero.casillas[45].ocupado
					||
					tablero.casillas[48].numjugador == 2 && tablero.casillas[40].ocupado && tablero.casillas[41].ocupado && tablero.casillas[47].ocupado && tablero.casillas[32].ocupado && tablero.casillas[34].ocupado && tablero.casillas[46].ocupado
				
					
			)
				{
					result = 1;
				}
		}
		else if (tipotabl == 3)
		{
			if (turno == 1)
			{
				//if (tablero.jugadores[numjug - 1].numFichaTotal<9)
				if (NumFicPat<8)
				{
					result = 2;
				}
			}
			if (tablero.casillas[2].numjugador == 2 && tablero.casillas[3].ocupado && tablero.casillas[9].ocupado && tablero.casillas[10].ocupado && tablero.casillas[4].ocupado && tablero.casillas[16].ocupado && tablero.casillas[18].ocupado		
					||
					tablero.casillas[3].numjugador == 2 && tablero.casillas[2].ocupado && tablero.casillas[4].ocupado && tablero.casillas[9].ocupado && tablero.casillas[10].ocupado && tablero.casillas[11].ocupado && tablero.casillas[17].ocupado 
					||
					tablero.casillas[4].numjugador == 2 && tablero.casillas[3].ocupado && tablero.casillas[10].ocupado && tablero.casillas[11].ocupado && tablero.casillas[2].ocupado && tablero.casillas[16].ocupado && tablero.casillas[18].ocupado 
					||
					tablero.casillas[9].numjugador == 2 && tablero.casillas[2].ocupado && tablero.casillas[3].ocupado  && tablero.casillas[10].ocupado && tablero.casillas[16].ocupado && tablero.casillas[17].ocupado	&& tablero.casillas[11].ocupado	&& tablero.casillas[23].ocupado && tablero.casillas[25].ocupado
					||
					tablero.casillas[10].numjugador == 2 && tablero.casillas[2].ocupado && tablero.casillas[3].ocupado && tablero.casillas[4].ocupado && tablero.casillas[9].ocupado && tablero.casillas[11].ocupado && tablero.casillas[16].ocupado && tablero.casillas[17].ocupado && tablero.casillas[18].ocupado && tablero.casillas[22].ocupado	&& tablero.casillas[24].ocupado	&& tablero.casillas[26].ocupado
					||
					tablero.casillas[11].numjugador == 2 && tablero.casillas[3].ocupado && tablero.casillas[4].ocupado && tablero.casillas[10].ocupado && tablero.casillas[17].ocupado && tablero.casillas[18].ocupado && tablero.casillas[9].ocupado && tablero.casillas[23].ocupado && tablero.casillas[25].ocupado 			
					||
					tablero.casillas[14].numjugador == 2 && tablero.casillas[15].ocupado && tablero.casillas[21].ocupado && tablero.casillas[22].ocupado && tablero.casillas[16].ocupado && tablero.casillas[30].ocupado && tablero.casillas[28].ocupado			
					||
					tablero.casillas[15].numjugador == 2 && tablero.casillas[14].ocupado && tablero.casillas[16].ocupado && tablero.casillas[21].ocupado && tablero.casillas[22].ocupado && tablero.casillas[23].ocupado && tablero.casillas[17].ocupado && tablero.casillas[29].ocupado && tablero.casillas[31].ocupado	
					||
					tablero.casillas[16].numjugador == 2 && tablero.casillas[9].ocupado && tablero.casillas[10].ocupado && tablero.casillas[15].ocupado && tablero.casillas[17].ocupado && tablero.casillas[22].ocupado && tablero.casillas[23].ocupado && tablero.casillas[24].ocupado && tablero.casillas[2].ocupado && tablero.casillas[4].ocupado	&& tablero.casillas[14].ocupado	&& tablero.casillas[18].ocupado	&& tablero.casillas[28].ocupado && tablero.casillas[30].ocupado && tablero.casillas[32].ocupado
					||
					tablero.casillas[17].numjugador == 2 && tablero.casillas[9].ocupado && tablero.casillas[10].ocupado && tablero.casillas[11].ocupado && tablero.casillas[16].ocupado && tablero.casillas[18].ocupado && tablero.casillas[23].ocupado && tablero.casillas[24].ocupado && tablero.casillas[25].ocupado && tablero.casillas[3].ocupado && tablero.casillas[15].ocupado && tablero.casillas[19].ocupado && tablero.casillas[29].ocupado && tablero.casillas[31].ocupado && tablero.casillas[33].ocupado			
					||
					tablero.casillas[18].numjugador == 2 && tablero.casillas[10].ocupado && tablero.casillas[11].ocupado && tablero.casillas[17].ocupado && tablero.casillas[19].ocupado && tablero.casillas[24].ocupado && tablero.casillas[25].ocupado && tablero.casillas[26].ocupado && tablero.casillas[2].ocupado && tablero.casillas[4].ocupado && tablero.casillas[16].ocupado && tablero.casillas[20].ocupado && tablero.casillas[30].ocupado && tablero.casillas[32].ocupado && tablero.casillas[34].ocupado
					||
					tablero.casillas[19].numjugador == 2 && tablero.casillas[18].ocupado && tablero.casillas[20].ocupado && tablero.casillas[25].ocupado && tablero.casillas[26].ocupado && tablero.casillas[27].ocupado && tablero.casillas[17].ocupado && tablero.casillas[31].ocupado && tablero.casillas[33].ocupado	
					||
					tablero.casillas[20].numjugador == 2 && tablero.casillas[19].ocupado && tablero.casillas[26].ocupado && tablero.casillas[27].ocupado && tablero.casillas[18].ocupado && tablero.casillas[32].ocupado && tablero.casillas[34].ocupado
					||
					tablero.casillas[21].numjugador == 2 && tablero.casillas[14].ocupado && tablero.casillas[15].ocupado && tablero.casillas[22].ocupado && tablero.casillas[28].ocupado && tablero.casillas[29].ocupado && tablero.casillas[23].ocupado 			
				    ||
					tablero.casillas[22].numjugador == 2 && tablero.casillas[14].ocupado && tablero.casillas[15].ocupado && tablero.casillas[16].ocupado && tablero.casillas[21].ocupado && tablero.casillas[23].ocupado && tablero.casillas[28].ocupado && tablero.casillas[29].ocupado && tablero.casillas[30].ocupado && tablero.casillas[10].ocupado	&& tablero.casillas[24].ocupado	&& tablero.casillas[38].ocupado 
					||
					tablero.casillas[23].numjugador == 2 && tablero.casillas[15].ocupado && tablero.casillas[16].ocupado && tablero.casillas[17].ocupado && tablero.casillas[22].ocupado && tablero.casillas[24].ocupado && tablero.casillas[29].ocupado && tablero.casillas[30].ocupado && tablero.casillas[31].ocupado && tablero.casillas[9].ocupado && tablero.casillas[11].ocupado && tablero.casillas[21].ocupado && tablero.casillas[25].ocupado && tablero.casillas[37].ocupado && tablero.casillas[39].ocupado
					||
					tablero.casillas[24].numjugador == 2 && tablero.casillas[16].ocupado && tablero.casillas[17].ocupado && tablero.casillas[18].ocupado && tablero.casillas[23].ocupado && tablero.casillas[25].ocupado && tablero.casillas[30].ocupado && tablero.casillas[31].ocupado && tablero.casillas[32].ocupado && tablero.casillas[10].ocupado && tablero.casillas[22].ocupado && tablero.casillas[26].ocupado && tablero.casillas[38].ocupado 
					||
					tablero.casillas[25].numjugador == 2 && tablero.casillas[17].ocupado && tablero.casillas[18].ocupado && tablero.casillas[19].ocupado && tablero.casillas[24].ocupado && tablero.casillas[26].ocupado && tablero.casillas[31].ocupado && tablero.casillas[32].ocupado && tablero.casillas[33].ocupado && tablero.casillas[9].ocupado && tablero.casillas[11].ocupado && tablero.casillas[23].ocupado && tablero.casillas[27].ocupado && tablero.casillas[37].ocupado && tablero.casillas[39].ocupado 
					||
					tablero.casillas[26].numjugador == 2 && tablero.casillas[18].ocupado && tablero.casillas[19].ocupado && tablero.casillas[20].ocupado && tablero.casillas[25].ocupado && tablero.casillas[27].ocupado && tablero.casillas[32].ocupado && tablero.casillas[33].ocupado && tablero.casillas[34].ocupado && tablero.casillas[10].ocupado && tablero.casillas[24].ocupado && tablero.casillas[38].ocupado 
					||
					tablero.casillas[27].numjugador == 2 && tablero.casillas[19].ocupado && tablero.casillas[20].ocupado && tablero.casillas[26].ocupado && tablero.casillas[33].ocupado && tablero.casillas[34].ocupado && tablero.casillas[25].ocupado  
					||
					tablero.casillas[28].numjugador == 2 && tablero.casillas[21].ocupado && tablero.casillas[22].ocupado && tablero.casillas[29].ocupado && tablero.casillas[14].ocupado && tablero.casillas[16].ocupado && tablero.casillas[30].ocupado 
					||
					tablero.casillas[29].numjugador == 2 && tablero.casillas[21].ocupado && tablero.casillas[22].ocupado && tablero.casillas[23].ocupado && tablero.casillas[28].ocupado && tablero.casillas[30].ocupado && tablero.casillas[15].ocupado && tablero.casillas[17].ocupado && tablero.casillas[31].ocupado 
					||
					tablero.casillas[30].numjugador == 2 && tablero.casillas[22].ocupado && tablero.casillas[23].ocupado && tablero.casillas[24].ocupado && tablero.casillas[29].ocupado && tablero.casillas[31].ocupado && tablero.casillas[37].ocupado && tablero.casillas[38].ocupado && tablero.casillas[14].ocupado && tablero.casillas[16].ocupado && tablero.casillas[18].ocupado && tablero.casillas[28].ocupado && tablero.casillas[32].ocupado && tablero.casillas[44].ocupado && tablero.casillas[46].ocupado
					||
					tablero.casillas[31].numjugador == 2 && tablero.casillas[23].ocupado && tablero.casillas[24].ocupado && tablero.casillas[25].ocupado && tablero.casillas[30].ocupado && tablero.casillas[32].ocupado && tablero.casillas[37].ocupado && tablero.casillas[38].ocupado && tablero.casillas[39].ocupado && tablero.casillas[15].ocupado && tablero.casillas[17].ocupado && tablero.casillas[19].ocupado && tablero.casillas[29].ocupado && tablero.casillas[33].ocupado && tablero.casillas[45].ocupado 
					||
					tablero.casillas[32].numjugador == 2 && tablero.casillas[24].ocupado && tablero.casillas[25].ocupado && tablero.casillas[26].ocupado && tablero.casillas[31].ocupado && tablero.casillas[33].ocupado && tablero.casillas[38].ocupado && tablero.casillas[39].ocupado && tablero.casillas[16].ocupado && tablero.casillas[18].ocupado && tablero.casillas[20].ocupado && tablero.casillas[30].ocupado && tablero.casillas[34].ocupado && tablero.casillas[44].ocupado && tablero.casillas[46].ocupado 
					||
					tablero.casillas[33].numjugador == 2 && tablero.casillas[25].ocupado && tablero.casillas[26].ocupado && tablero.casillas[27].ocupado && tablero.casillas[32].ocupado && tablero.casillas[34].ocupado && tablero.casillas[17].ocupado && tablero.casillas[19].ocupado && tablero.casillas[31].ocupado 
					||
					tablero.casillas[34].numjugador == 2 && tablero.casillas[26].ocupado && tablero.casillas[27].ocupado && tablero.casillas[33].ocupado && tablero.casillas[18].ocupado && tablero.casillas[20].ocupado && tablero.casillas[32].ocupado
					||
					tablero.casillas[37].numjugador == 2 && tablero.casillas[30].ocupado && tablero.casillas[31].ocupado && tablero.casillas[38].ocupado && tablero.casillas[44].ocupado && tablero.casillas[45].ocupado && tablero.casillas[23].ocupado && tablero.casillas[25].ocupado && tablero.casillas[39].ocupado
					||
					tablero.casillas[38].numjugador == 2 && tablero.casillas[30].ocupado && tablero.casillas[31].ocupado && tablero.casillas[32].ocupado && tablero.casillas[37].ocupado && tablero.casillas[39].ocupado && tablero.casillas[44].ocupado && tablero.casillas[45].ocupado && tablero.casillas[46].ocupado && tablero.casillas[22].ocupado && tablero.casillas[24].ocupado && tablero.casillas[26].ocupado 
					||
					tablero.casillas[39].numjugador == 2 && tablero.casillas[31].ocupado && tablero.casillas[32].ocupado && tablero.casillas[38].ocupado && tablero.casillas[45].ocupado && tablero.casillas[46].ocupado && tablero.casillas[23].ocupado && tablero.casillas[25].ocupado && tablero.casillas[37].ocupado
					||
					tablero.casillas[44].numjugador == 2 && tablero.casillas[37].ocupado && tablero.casillas[38].ocupado && tablero.casillas[45].ocupado && tablero.casillas[30].ocupado && tablero.casillas[32].ocupado && tablero.casillas[46].ocupado
					||
					tablero.casillas[45].numjugador == 2 && tablero.casillas[37].ocupado && tablero.casillas[38].ocupado && tablero.casillas[39].ocupado && tablero.casillas[44].ocupado && tablero.casillas[46].ocupado && tablero.casillas[31].ocupado  
					||
					tablero.casillas[46].numjugador == 2 && tablero.casillas[38].ocupado && tablero.casillas[39].ocupado && tablero.casillas[45].ocupado && tablero.casillas[30].ocupado && tablero.casillas[32].ocupado && tablero.casillas[44].ocupado 
					
					
			)
				{
					result = 1;
				}
		}
		else
			if (tipotabl == 4)
			{
			if (turno == 1)
			{
				//if (tablero.jugadores[numjug - 1].numFichaTotal<9)
				if (NumFicPat<11)// || numMovimientos == 2)
				{
					result = 2;
				}
				result = 1;
			}
			
			
			if (tablero.casillas[0].numjugador == 2 && tablero.casillas[1].ocupado && tablero.casillas[2].ocupado && tablero.casillas[5].ocupado && tablero.casillas[6].ocupado && tablero.casillas[10].ocupado && tablero.casillas[12].ocupado
				||
				tablero.casillas[1].numjugador == 2 && tablero.casillas[0].ocupado && tablero.casillas[2].ocupado && tablero.casillas[3].ocupado && tablero.casillas[6].ocupado && tablero.casillas[11].ocupado 			
			    ||
				tablero.casillas[2].numjugador == 2 && tablero.casillas[1].ocupado && tablero.casillas[3].ocupado && tablero.casillas[6].ocupado && tablero.casillas[7].ocupado && tablero.casillas[8].ocupado && tablero.casillas[10].ocupado && tablero.casillas[12].ocupado && tablero.casillas[14].ocupado && tablero.casillas[4].ocupado		
				||
				tablero.casillas[3].numjugador == 2 && tablero.casillas[2].ocupado && tablero.casillas[4].ocupado && tablero.casillas[8].ocupado && tablero.casillas[13].ocupado && tablero.casillas[1].ocupado
				||
				tablero.casillas[4].numjugador == 2 && tablero.casillas[2].ocupado && tablero.casillas[3].ocupado && tablero.casillas[8].ocupado && tablero.casillas[9].ocupado && tablero.casillas[12].ocupado && tablero.casillas[14].ocupado
				||
				tablero.casillas[5].numjugador == 2 && tablero.casillas[0].ocupado && tablero.casillas[6].ocupado && tablero.casillas[10].ocupado && tablero.casillas[15].ocupado && tablero.casillas[7].ocupado			
				||
				tablero.casillas[6].numjugador == 2 && tablero.casillas[0].ocupado && tablero.casillas[1].ocupado && tablero.casillas[2].ocupado && tablero.casillas[5].ocupado && tablero.casillas[7].ocupado && tablero.casillas[10].ocupado && tablero.casillas[11].ocupado && tablero.casillas[12].ocupado && tablero.casillas[16].ocupado && tablero.casillas[18].ocupado && tablero.casillas[8].ocupado			
				||
				tablero.casillas[7].numjugador == 2 && tablero.casillas[2].ocupado && tablero.casillas[6].ocupado && tablero.casillas[8].ocupado && tablero.casillas[12].ocupado && tablero.casillas[5].ocupado && tablero.casillas[17].ocupado && tablero.casillas[9].ocupado			
				||
				tablero.casillas[8].numjugador == 2 && tablero.casillas[2].ocupado && tablero.casillas[3].ocupado && tablero.casillas[4].ocupado && tablero.casillas[7].ocupado && tablero.casillas[9].ocupado && tablero.casillas[12].ocupado && tablero.casillas[13].ocupado && tablero.casillas[14].ocupado && tablero.casillas[6].ocupado && tablero.casillas[16].ocupado && tablero.casillas[18].ocupado
				||
				tablero.casillas[9].numjugador == 2 && tablero.casillas[4].ocupado && tablero.casillas[8].ocupado && tablero.casillas[14].ocupado && tablero.casillas[7].ocupado && tablero.casillas[19].ocupado			
				||
				tablero.casillas[10].numjugador == 2 && tablero.casillas[5].ocupado && tablero.casillas[6].ocupado && tablero.casillas[11].ocupado && tablero.casillas[16].ocupado && tablero.casillas[15].ocupado && tablero.casillas[0].ocupado && tablero.casillas[2].ocupado && tablero.casillas[12].ocupado && tablero.casillas[22].ocupado && tablero.casillas[20].ocupado			
				||
				tablero.casillas[11].numjugador == 2 && tablero.casillas[6].ocupado && tablero.casillas[10].ocupado && tablero.casillas[12].ocupado && tablero.casillas[16].ocupado && tablero.casillas[1].ocupado && tablero.casillas[13].ocupado && tablero.casillas[21].ocupado			
				||
				tablero.casillas[12].numjugador == 2 && tablero.casillas[6].ocupado && tablero.casillas[7].ocupado && tablero.casillas[8].ocupado && tablero.casillas[11].ocupado && tablero.casillas[13].ocupado && tablero.casillas[16].ocupado && tablero.casillas[17].ocupado && tablero.casillas[18].ocupado && tablero.casillas[0].ocupado && tablero.casillas[2].ocupado && tablero.casillas[4].ocupado && tablero.casillas[10].ocupado && tablero.casillas[14].ocupado && tablero.casillas[20].ocupado && tablero.casillas[22].ocupado && tablero.casillas[24].ocupado			
				||
				tablero.casillas[13].numjugador == 2 && tablero.casillas[8].ocupado && tablero.casillas[12].ocupado && tablero.casillas[14].ocupado && tablero.casillas[18].ocupado && tablero.casillas[3].ocupado && tablero.casillas[23].ocupado && tablero.casillas[11].ocupado			
				||
				tablero.casillas[14].numjugador == 2 && tablero.casillas[8].ocupado && tablero.casillas[9].ocupado && tablero.casillas[13].ocupado && tablero.casillas[18].ocupado && tablero.casillas[19].ocupado && tablero.casillas[4].ocupado && tablero.casillas[2].ocupado && tablero.casillas[12].ocupado && tablero.casillas[22].ocupado && tablero.casillas[24].ocupado			
				||
				tablero.casillas[15].numjugador == 2 && tablero.casillas[10].ocupado && tablero.casillas[16].ocupado&& tablero.casillas[20].ocupado && tablero.casillas[5].ocupado && tablero.casillas[17].ocupado			
				||
				tablero.casillas[16].numjugador == 2 && tablero.casillas[10].ocupado && tablero.casillas[11].ocupado && tablero.casillas[12].ocupado && tablero.casillas[15].ocupado && tablero.casillas[17].ocupado && tablero.casillas[20].ocupado && tablero.casillas[21].ocupado && tablero.casillas[22].ocupado && tablero.casillas[6].ocupado && tablero.casillas[8].ocupado && tablero.casillas[18].ocupado			
				||
				tablero.casillas[17].numjugador == 2 && tablero.casillas[12].ocupado && tablero.casillas[16].ocupado && tablero.casillas[18].ocupado && tablero.casillas[22].ocupado && tablero.casillas[15].ocupado && tablero.casillas[7].ocupado && tablero.casillas[19].ocupado			
				||
				tablero.casillas[18].numjugador == 2 && tablero.casillas[12].ocupado && tablero.casillas[13].ocupado && tablero.casillas[14].ocupado && tablero.casillas[17].ocupado && tablero.casillas[19].ocupado && tablero.casillas[22].ocupado && tablero.casillas[23].ocupado && tablero.casillas[24].ocupado && tablero.casillas[6].ocupado && tablero.casillas[16].ocupado && tablero.casillas[8].ocupado
				||
				tablero.casillas[19].numjugador == 2 && tablero.casillas[14].ocupado && tablero.casillas[18].ocupado && tablero.casillas[24].ocupado && tablero.casillas[17].ocupado && tablero.casillas[9].ocupado			
				||
				tablero.casillas[20].numjugador == 2 && tablero.casillas[21].ocupado && tablero.casillas[22].ocupado && tablero.casillas[15].ocupado && tablero.casillas[16].ocupado && tablero.casillas[10].ocupado && tablero.casillas[12].ocupado
				||
				tablero.casillas[21].numjugador == 2 && tablero.casillas[20].ocupado && tablero.casillas[22].ocupado && tablero.casillas[23].ocupado && tablero.casillas[16].ocupado && tablero.casillas[11].ocupado			
			    ||
				tablero.casillas[22].numjugador == 2 && tablero.casillas[21].ocupado && tablero.casillas[23].ocupado && tablero.casillas[16].ocupado && tablero.casillas[17].ocupado && tablero.casillas[18].ocupado && tablero.casillas[10].ocupado && tablero.casillas[12].ocupado && tablero.casillas[14].ocupado && tablero.casillas[24].ocupado			
				||
				tablero.casillas[23].numjugador == 2 && tablero.casillas[22].ocupado && tablero.casillas[24].ocupado && tablero.casillas[18].ocupado && tablero.casillas[13].ocupado
				||
				tablero.casillas[24].numjugador == 2 && tablero.casillas[22].ocupado && tablero.casillas[23].ocupado && tablero.casillas[18].ocupado && tablero.casillas[19].ocupado && tablero.casillas[12].ocupado && tablero.casillas[14].ocupado
			)
			{
				result = 1;
			}
			
			}
			else if (tipotabl == 5)
			{
				if (turno == 1)
				{
					//if (tablero.jugadores[numjug - 1].numFichaTotal<9)
					if (NumFicPat<8)
					{
						result = 2;
					}
				}
				if (tablero.casillas[2].numjugador == 2 && tablero.casillas[3].ocupado && tablero.casillas[9].ocupado && tablero.casillas[10].ocupado && tablero.casillas[4].ocupado && tablero.casillas[16].ocupado && tablero.casillas[18].ocupado		
						||
						tablero.casillas[3].numjugador == 2 && tablero.casillas[2].ocupado && tablero.casillas[4].ocupado && tablero.casillas[10].ocupado && tablero.casillas[17].ocupado 
						||
						tablero.casillas[4].numjugador == 2 && tablero.casillas[3].ocupado && tablero.casillas[10].ocupado && tablero.casillas[11].ocupado && tablero.casillas[2].ocupado && tablero.casillas[16].ocupado && tablero.casillas[18].ocupado 
						||
						tablero.casillas[9].numjugador == 2 && tablero.casillas[2].ocupado  && tablero.casillas[10].ocupado && tablero.casillas[16].ocupado && tablero.casillas[11].ocupado	&& tablero.casillas[23].ocupado 
						||
						tablero.casillas[10].numjugador == 2 && tablero.casillas[2].ocupado && tablero.casillas[3].ocupado && tablero.casillas[4].ocupado && tablero.casillas[9].ocupado && tablero.casillas[11].ocupado && tablero.casillas[16].ocupado && tablero.casillas[17].ocupado && tablero.casillas[18].ocupado && tablero.casillas[22].ocupado	&& tablero.casillas[24].ocupado	&& tablero.casillas[26].ocupado
						||
						tablero.casillas[11].numjugador == 2 && tablero.casillas[4].ocupado && tablero.casillas[10].ocupado && tablero.casillas[18].ocupado && tablero.casillas[9].ocupado && tablero.casillas[25].ocupado 			
						||
						tablero.casillas[14].numjugador == 2 && tablero.casillas[15].ocupado && tablero.casillas[21].ocupado && tablero.casillas[22].ocupado && tablero.casillas[16].ocupado && tablero.casillas[30].ocupado && tablero.casillas[28].ocupado			
						||
						tablero.casillas[15].numjugador == 2 && tablero.casillas[14].ocupado && tablero.casillas[16].ocupado && tablero.casillas[22].ocupado && tablero.casillas[17].ocupado && tablero.casillas[29].ocupado	
						||
						tablero.casillas[16].numjugador == 2 && tablero.casillas[9].ocupado && tablero.casillas[10].ocupado && tablero.casillas[15].ocupado && tablero.casillas[17].ocupado && tablero.casillas[22].ocupado && tablero.casillas[23].ocupado && tablero.casillas[24].ocupado && tablero.casillas[2].ocupado && tablero.casillas[4].ocupado	&& tablero.casillas[14].ocupado	&& tablero.casillas[18].ocupado	&& tablero.casillas[28].ocupado && tablero.casillas[30].ocupado && tablero.casillas[32].ocupado
						||
						tablero.casillas[17].numjugador == 2 && tablero.casillas[10].ocupado && tablero.casillas[16].ocupado && tablero.casillas[18].ocupado && tablero.casillas[24].ocupado && tablero.casillas[3].ocupado && tablero.casillas[15].ocupado && tablero.casillas[19].ocupado && tablero.casillas[31].ocupado 			
						||
						tablero.casillas[18].numjugador == 2 && tablero.casillas[10].ocupado && tablero.casillas[11].ocupado && tablero.casillas[17].ocupado && tablero.casillas[19].ocupado && tablero.casillas[24].ocupado && tablero.casillas[25].ocupado && tablero.casillas[26].ocupado && tablero.casillas[2].ocupado && tablero.casillas[4].ocupado && tablero.casillas[16].ocupado && tablero.casillas[20].ocupado && tablero.casillas[30].ocupado && tablero.casillas[32].ocupado && tablero.casillas[34].ocupado
						||
						tablero.casillas[19].numjugador == 2 && tablero.casillas[18].ocupado && tablero.casillas[20].ocupado && tablero.casillas[26].ocupado && tablero.casillas[17].ocupado && tablero.casillas[33].ocupado	
						||
						tablero.casillas[20].numjugador == 2 && tablero.casillas[19].ocupado && tablero.casillas[26].ocupado && tablero.casillas[27].ocupado && tablero.casillas[18].ocupado && tablero.casillas[32].ocupado && tablero.casillas[34].ocupado
						||
						tablero.casillas[21].numjugador == 2 && tablero.casillas[14].ocupado && tablero.casillas[22].ocupado && tablero.casillas[28].ocupado && tablero.casillas[23].ocupado 			
					    ||
						tablero.casillas[22].numjugador == 2 && tablero.casillas[14].ocupado && tablero.casillas[15].ocupado && tablero.casillas[16].ocupado && tablero.casillas[21].ocupado && tablero.casillas[23].ocupado && tablero.casillas[28].ocupado && tablero.casillas[29].ocupado && tablero.casillas[30].ocupado && tablero.casillas[10].ocupado	&& tablero.casillas[24].ocupado	&& tablero.casillas[38].ocupado 
						||
						tablero.casillas[23].numjugador == 2 && tablero.casillas[16].ocupado && tablero.casillas[22].ocupado && tablero.casillas[24].ocupado && tablero.casillas[30].ocupado && tablero.casillas[9].ocupado && tablero.casillas[21].ocupado && tablero.casillas[25].ocupado && tablero.casillas[37].ocupado 
						||
						tablero.casillas[24].numjugador == 2 && tablero.casillas[16].ocupado && tablero.casillas[17].ocupado && tablero.casillas[18].ocupado && tablero.casillas[23].ocupado && tablero.casillas[25].ocupado && tablero.casillas[30].ocupado && tablero.casillas[31].ocupado && tablero.casillas[32].ocupado && tablero.casillas[10].ocupado && tablero.casillas[22].ocupado && tablero.casillas[26].ocupado && tablero.casillas[38].ocupado 
						||
						tablero.casillas[25].numjugador == 2 && tablero.casillas[18].ocupado && tablero.casillas[24].ocupado && tablero.casillas[26].ocupado && tablero.casillas[32].ocupado && tablero.casillas[11].ocupado && tablero.casillas[23].ocupado && tablero.casillas[27].ocupado && tablero.casillas[39].ocupado 
						||
						tablero.casillas[26].numjugador == 2 && tablero.casillas[18].ocupado && tablero.casillas[19].ocupado && tablero.casillas[20].ocupado && tablero.casillas[25].ocupado && tablero.casillas[27].ocupado && tablero.casillas[32].ocupado && tablero.casillas[33].ocupado && tablero.casillas[34].ocupado && tablero.casillas[10].ocupado && tablero.casillas[24].ocupado && tablero.casillas[38].ocupado 
						||
						tablero.casillas[27].numjugador == 2 && tablero.casillas[20].ocupado && tablero.casillas[26].ocupado && tablero.casillas[34].ocupado && tablero.casillas[25].ocupado  
						||
						tablero.casillas[28].numjugador == 2 && tablero.casillas[21].ocupado && tablero.casillas[22].ocupado && tablero.casillas[29].ocupado && tablero.casillas[14].ocupado && tablero.casillas[16].ocupado && tablero.casillas[30].ocupado 
						||
						tablero.casillas[29].numjugador == 2 && tablero.casillas[22].ocupado && tablero.casillas[28].ocupado && tablero.casillas[30].ocupado && tablero.casillas[15].ocupado && tablero.casillas[31].ocupado 
						||
						tablero.casillas[30].numjugador == 2 && tablero.casillas[22].ocupado && tablero.casillas[23].ocupado && tablero.casillas[24].ocupado && tablero.casillas[29].ocupado && tablero.casillas[31].ocupado && tablero.casillas[37].ocupado && tablero.casillas[38].ocupado && tablero.casillas[14].ocupado && tablero.casillas[16].ocupado && tablero.casillas[18].ocupado && tablero.casillas[28].ocupado && tablero.casillas[32].ocupado && tablero.casillas[44].ocupado && tablero.casillas[46].ocupado
						||
						tablero.casillas[31].numjugador == 2 && tablero.casillas[24].ocupado && tablero.casillas[30].ocupado && tablero.casillas[32].ocupado && tablero.casillas[38].ocupado && tablero.casillas[17].ocupado && tablero.casillas[29].ocupado && tablero.casillas[33].ocupado && tablero.casillas[45].ocupado 
						||
						tablero.casillas[32].numjugador == 2 && tablero.casillas[24].ocupado && tablero.casillas[25].ocupado && tablero.casillas[26].ocupado && tablero.casillas[31].ocupado && tablero.casillas[33].ocupado && tablero.casillas[38].ocupado && tablero.casillas[39].ocupado && tablero.casillas[16].ocupado && tablero.casillas[18].ocupado && tablero.casillas[20].ocupado && tablero.casillas[30].ocupado && tablero.casillas[34].ocupado && tablero.casillas[44].ocupado && tablero.casillas[46].ocupado 
						||
						tablero.casillas[33].numjugador == 2 && tablero.casillas[26].ocupado && tablero.casillas[32].ocupado && tablero.casillas[34].ocupado && tablero.casillas[17].ocupado && tablero.casillas[19].ocupado && tablero.casillas[31].ocupado 
						||
						tablero.casillas[34].numjugador == 2 && tablero.casillas[26].ocupado && tablero.casillas[27].ocupado && tablero.casillas[33].ocupado && tablero.casillas[18].ocupado && tablero.casillas[20].ocupado && tablero.casillas[32].ocupado
						||
						tablero.casillas[37].numjugador == 2 && tablero.casillas[30].ocupado && tablero.casillas[38].ocupado && tablero.casillas[44].ocupado && tablero.casillas[23].ocupado && tablero.casillas[39].ocupado
						||
						tablero.casillas[38].numjugador == 2 && tablero.casillas[30].ocupado && tablero.casillas[31].ocupado && tablero.casillas[32].ocupado && tablero.casillas[37].ocupado && tablero.casillas[39].ocupado && tablero.casillas[44].ocupado && tablero.casillas[45].ocupado && tablero.casillas[46].ocupado && tablero.casillas[22].ocupado && tablero.casillas[24].ocupado && tablero.casillas[26].ocupado 
						||
						tablero.casillas[39].numjugador == 2 && tablero.casillas[32].ocupado && tablero.casillas[38].ocupado && tablero.casillas[46].ocupado && tablero.casillas[25].ocupado && tablero.casillas[37].ocupado
						||
						tablero.casillas[44].numjugador == 2 && tablero.casillas[37].ocupado && tablero.casillas[38].ocupado && tablero.casillas[45].ocupado && tablero.casillas[30].ocupado && tablero.casillas[32].ocupado && tablero.casillas[46].ocupado
						||
						tablero.casillas[45].numjugador == 2 && tablero.casillas[38].ocupado && tablero.casillas[44].ocupado && tablero.casillas[46].ocupado && tablero.casillas[31].ocupado  
						||
						tablero.casillas[46].numjugador == 2 && tablero.casillas[38].ocupado && tablero.casillas[39].ocupado && tablero.casillas[45].ocupado && tablero.casillas[30].ocupado && tablero.casillas[32].ocupado && tablero.casillas[44].ocupado 
						
						
				)
					{
						result = 1;
					}
			}//FIN TIPOTABLE 5
			else
				if (tipotabl == 6)
				{
					if (turno == 1)
					{
						//if (tablero.jugadores[numjug - 1].numFichaTotal<9)
						if (NumFicPat<15)
						{
							result = 2;
						}
					}
					if (tablero.casillas[0].numjugador == 2 && tablero.casillas[1].ocupado && tablero.casillas[7].ocupado && tablero.casillas[8].ocupado && tablero.casillas[2].ocupado && tablero.casillas[16].ocupado && tablero.casillas[14].ocupado
							||
							tablero.casillas[1].numjugador == 2 && tablero.casillas[0].ocupado && tablero.casillas[2].ocupado && tablero.casillas[3].ocupado && tablero.casillas[8].ocupado && tablero.casillas[15].ocupado 		
						    ||
							tablero.casillas[2].numjugador == 2 && tablero.casillas[1].ocupado && tablero.casillas[3].ocupado && tablero.casillas[8].ocupado && tablero.casillas[9].ocupado && tablero.casillas[10].ocupado && tablero.casillas[0].ocupado && tablero.casillas[4].ocupado && tablero.casillas[14].ocupado && tablero.casillas[18].ocupado		
							||
							tablero.casillas[3].numjugador == 2 && tablero.casillas[2].ocupado && tablero.casillas[4].ocupado && tablero.casillas[10].ocupado && tablero.casillas[1].ocupado && tablero.casillas[5].ocupado && tablero.casillas[17].ocupado 
							||
							tablero.casillas[4].numjugador == 2 && tablero.casillas[3].ocupado && tablero.casillas[5].ocupado && tablero.casillas[10].ocupado && tablero.casillas[11].ocupado && tablero.casillas[12].ocupado && tablero.casillas[2].ocupado && tablero.casillas[6].ocupado && tablero.casillas[16].ocupado && tablero.casillas[18].ocupado && tablero.casillas[20].ocupado
							||
							tablero.casillas[5].numjugador == 2 && tablero.casillas[4].ocupado && tablero.casillas[6].ocupado && tablero.casillas[12].ocupado  && tablero.casillas[3].ocupado && tablero.casillas[19].ocupado			
							||
							tablero.casillas[6].numjugador == 2 && tablero.casillas[5].ocupado && tablero.casillas[12].ocupado && tablero.casillas[13].ocupado && tablero.casillas[4].ocupado && tablero.casillas[18].ocupado && tablero.casillas[20].ocupado 
							||
							tablero.casillas[7].numjugador == 2 && tablero.casillas[0].ocupado && tablero.casillas[8].ocupado && tablero.casillas[14].ocupado && tablero.casillas[9].ocupado && tablero.casillas[21].ocupado 
							||
							tablero.casillas[8].numjugador == 2 && tablero.casillas[0].ocupado && tablero.casillas[1].ocupado && tablero.casillas[2].ocupado && tablero.casillas[7].ocupado && tablero.casillas[9].ocupado && tablero.casillas[14].ocupado && tablero.casillas[15].ocupado && tablero.casillas[16].ocupado && tablero.casillas[10].ocupado && tablero.casillas[24].ocupado && tablero.casillas[22].ocupado
							||
							tablero.casillas[9].numjugador == 2 && tablero.casillas[2].ocupado && tablero.casillas[8].ocupado && tablero.casillas[10].ocupado && tablero.casillas[16].ocupado && tablero.casillas[7].ocupado	&& tablero.casillas[11].ocupado	&& tablero.casillas[23].ocupado 
							||
							tablero.casillas[10].numjugador == 2 && tablero.casillas[2].ocupado && tablero.casillas[3].ocupado && tablero.casillas[4].ocupado && tablero.casillas[9].ocupado && tablero.casillas[11].ocupado && tablero.casillas[16].ocupado && tablero.casillas[17].ocupado && tablero.casillas[18].ocupado && tablero.casillas[8].ocupado && tablero.casillas[12].ocupado	&& tablero.casillas[22].ocupado	&& tablero.casillas[24].ocupado	&& tablero.casillas[26].ocupado
							||
							tablero.casillas[11].numjugador == 2 && tablero.casillas[4].ocupado && tablero.casillas[10].ocupado && tablero.casillas[12].ocupado && tablero.casillas[18].ocupado && tablero.casillas[9].ocupado && tablero.casillas[25].ocupado 	&& tablero.casillas[13].ocupado		
							||
							tablero.casillas[12].numjugador == 2 && tablero.casillas[4].ocupado && tablero.casillas[5].ocupado && tablero.casillas[6].ocupado && tablero.casillas[11].ocupado && tablero.casillas[13].ocupado && tablero.casillas[18].ocupado && tablero.casillas[19].ocupado && tablero.casillas[20].ocupado && tablero.casillas[10].ocupado && tablero.casillas[24].ocupado && tablero.casillas[26].ocupado			
							||
							tablero.casillas[13].numjugador == 2 && tablero.casillas[6].ocupado && tablero.casillas[12].ocupado && tablero.casillas[20].ocupado && tablero.casillas[11].ocupado && tablero.casillas[27].ocupado			
							||
							tablero.casillas[14].numjugador == 2 && tablero.casillas[7].ocupado && tablero.casillas[8].ocupado && tablero.casillas[15].ocupado && tablero.casillas[21].ocupado && tablero.casillas[22].ocupado && tablero.casillas[0].ocupado && tablero.casillas[2].ocupado && tablero.casillas[16].ocupado && tablero.casillas[30].ocupado && tablero.casillas[28].ocupado			
							||
							tablero.casillas[15].numjugador == 2 && tablero.casillas[8].ocupado && tablero.casillas[14].ocupado && tablero.casillas[16].ocupado && tablero.casillas[22].ocupado && tablero.casillas[1].ocupado && tablero.casillas[17].ocupado	&& tablero.casillas[29].ocupado		
							||
							tablero.casillas[16].numjugador == 2 && tablero.casillas[8].ocupado && tablero.casillas[9].ocupado && tablero.casillas[10].ocupado && tablero.casillas[15].ocupado && tablero.casillas[17].ocupado && tablero.casillas[22].ocupado && tablero.casillas[23].ocupado && tablero.casillas[24].ocupado && tablero.casillas[0].ocupado && tablero.casillas[2].ocupado && tablero.casillas[4].ocupado	&& tablero.casillas[14].ocupado	&& tablero.casillas[18].ocupado	&& tablero.casillas[28].ocupado && tablero.casillas[30].ocupado && tablero.casillas[32].ocupado
							||
							tablero.casillas[17].numjugador == 2 && tablero.casillas[10].ocupado && tablero.casillas[16].ocupado && tablero.casillas[18].ocupado && tablero.casillas[24].ocupado && tablero.casillas[3].ocupado && tablero.casillas[15].ocupado && tablero.casillas[19].ocupado && tablero.casillas[31].ocupado 			
							||
							tablero.casillas[18].numjugador == 2 && tablero.casillas[10].ocupado && tablero.casillas[11].ocupado && tablero.casillas[12].ocupado && tablero.casillas[17].ocupado && tablero.casillas[19].ocupado && tablero.casillas[24].ocupado && tablero.casillas[25].ocupado && tablero.casillas[26].ocupado && tablero.casillas[2].ocupado && tablero.casillas[4].ocupado && tablero.casillas[6].ocupado && tablero.casillas[16].ocupado && tablero.casillas[20].ocupado && tablero.casillas[30].ocupado && tablero.casillas[32].ocupado && tablero.casillas[34].ocupado
							||
							tablero.casillas[19].numjugador == 2 && tablero.casillas[12].ocupado && tablero.casillas[18].ocupado && tablero.casillas[20].ocupado && tablero.casillas[26].ocupado && tablero.casillas[5].ocupado && tablero.casillas[17].ocupado && tablero.casillas[33].ocupado	
							||
							tablero.casillas[20].numjugador == 2 && tablero.casillas[12].ocupado && tablero.casillas[13].ocupado && tablero.casillas[19].ocupado && tablero.casillas[26].ocupado && tablero.casillas[27].ocupado && tablero.casillas[4].ocupado && tablero.casillas[18].ocupado && tablero.casillas[32].ocupado && tablero.casillas[34].ocupado
							||
							tablero.casillas[21].numjugador == 2 && tablero.casillas[14].ocupado && tablero.casillas[22].ocupado && tablero.casillas[28].ocupado && tablero.casillas[7].ocupado  && tablero.casillas[23].ocupado && tablero.casillas[35].ocupado			
						    ||
							tablero.casillas[22].numjugador == 2 && tablero.casillas[14].ocupado && tablero.casillas[15].ocupado && tablero.casillas[16].ocupado && tablero.casillas[21].ocupado && tablero.casillas[23].ocupado && tablero.casillas[28].ocupado && tablero.casillas[29].ocupado && tablero.casillas[30].ocupado && tablero.casillas[8].ocupado	&& tablero.casillas[10].ocupado	&& tablero.casillas[24].ocupado	&& tablero.casillas[38].ocupado && tablero.casillas[36].ocupado
							||
							tablero.casillas[23].numjugador == 2 && tablero.casillas[16].ocupado && tablero.casillas[22].ocupado && tablero.casillas[24].ocupado && tablero.casillas[30].ocupado && tablero.casillas[9].ocupado && tablero.casillas[21].ocupado && tablero.casillas[25].ocupado  && tablero.casillas[37].ocupado 
							||
							tablero.casillas[24].numjugador == 2 && tablero.casillas[16].ocupado && tablero.casillas[17].ocupado && tablero.casillas[18].ocupado && tablero.casillas[23].ocupado && tablero.casillas[25].ocupado && tablero.casillas[30].ocupado && tablero.casillas[31].ocupado && tablero.casillas[32].ocupado && tablero.casillas[8].ocupado && tablero.casillas[10].ocupado && tablero.casillas[12].ocupado && tablero.casillas[22].ocupado && tablero.casillas[26].ocupado && tablero.casillas[36].ocupado && tablero.casillas[38].ocupado && tablero.casillas[40].ocupado
							||
							tablero.casillas[25].numjugador == 2 && tablero.casillas[18].ocupado && tablero.casillas[24].ocupado && tablero.casillas[26].ocupado && tablero.casillas[32].ocupado && tablero.casillas[11].ocupado && tablero.casillas[23].ocupado && tablero.casillas[27].ocupado && tablero.casillas[39].ocupado 
							||
							tablero.casillas[26].numjugador == 2 && tablero.casillas[18].ocupado && tablero.casillas[19].ocupado && tablero.casillas[20].ocupado && tablero.casillas[25].ocupado && tablero.casillas[27].ocupado && tablero.casillas[32].ocupado && tablero.casillas[33].ocupado && tablero.casillas[34].ocupado && tablero.casillas[10].ocupado && tablero.casillas[12].ocupado && tablero.casillas[24].ocupado && tablero.casillas[38].ocupado && tablero.casillas[40].ocupado
							||
							tablero.casillas[27].numjugador == 2 && tablero.casillas[20].ocupado && tablero.casillas[26].ocupado && tablero.casillas[34].ocupado && tablero.casillas[13].ocupado && tablero.casillas[25].ocupado && tablero.casillas[41].ocupado 
							||
							tablero.casillas[28].numjugador == 2 && tablero.casillas[21].ocupado && tablero.casillas[22].ocupado && tablero.casillas[29].ocupado && tablero.casillas[35].ocupado && tablero.casillas[36].ocupado && tablero.casillas[14].ocupado && tablero.casillas[16].ocupado && tablero.casillas[30].ocupado && tablero.casillas[42].ocupado && tablero.casillas[44].ocupado
							||
							tablero.casillas[29].numjugador == 2 && tablero.casillas[22].ocupado && tablero.casillas[28].ocupado && tablero.casillas[30].ocupado && tablero.casillas[36].ocupado && tablero.casillas[15].ocupado && tablero.casillas[31].ocupado && tablero.casillas[43].ocupado 
							||
							tablero.casillas[30].numjugador == 2 && tablero.casillas[22].ocupado && tablero.casillas[23].ocupado && tablero.casillas[24].ocupado && tablero.casillas[29].ocupado && tablero.casillas[31].ocupado && tablero.casillas[36].ocupado && tablero.casillas[37].ocupado && tablero.casillas[38].ocupado && tablero.casillas[14].ocupado && tablero.casillas[16].ocupado && tablero.casillas[18].ocupado && tablero.casillas[28].ocupado && tablero.casillas[32].ocupado && tablero.casillas[42].ocupado && tablero.casillas[44].ocupado && tablero.casillas[46].ocupado
							||
							tablero.casillas[31].numjugador == 2 && tablero.casillas[24].ocupado && tablero.casillas[30].ocupado && tablero.casillas[32].ocupado && tablero.casillas[38].ocupado && tablero.casillas[17].ocupado && tablero.casillas[29].ocupado && tablero.casillas[33].ocupado && tablero.casillas[45].ocupado 
							||
							tablero.casillas[32].numjugador == 2 && tablero.casillas[24].ocupado && tablero.casillas[25].ocupado && tablero.casillas[26].ocupado && tablero.casillas[31].ocupado && tablero.casillas[33].ocupado && tablero.casillas[38].ocupado && tablero.casillas[39].ocupado && tablero.casillas[40].ocupado && tablero.casillas[16].ocupado && tablero.casillas[18].ocupado && tablero.casillas[20].ocupado && tablero.casillas[30].ocupado && tablero.casillas[34].ocupado && tablero.casillas[44].ocupado && tablero.casillas[46].ocupado && tablero.casillas[48].ocupado
							||
							tablero.casillas[33].numjugador == 2 && tablero.casillas[26].ocupado && tablero.casillas[32].ocupado && tablero.casillas[34].ocupado && tablero.casillas[40].ocupado && tablero.casillas[19].ocupado && tablero.casillas[31].ocupado && tablero.casillas[47].ocupado
							||
							tablero.casillas[34].numjugador == 2 && tablero.casillas[26].ocupado && tablero.casillas[27].ocupado && tablero.casillas[33].ocupado && tablero.casillas[40].ocupado && tablero.casillas[41].ocupado && tablero.casillas[18].ocupado && tablero.casillas[20].ocupado && tablero.casillas[32].ocupado && tablero.casillas[46].ocupado && tablero.casillas[48].ocupado
							||
							tablero.casillas[35].numjugador == 2 && tablero.casillas[28].ocupado && tablero.casillas[36].ocupado && tablero.casillas[42].ocupado && tablero.casillas[21].ocupado && tablero.casillas[37].ocupado
							||
							tablero.casillas[36].numjugador == 2 && tablero.casillas[28].ocupado && tablero.casillas[29].ocupado && tablero.casillas[30].ocupado && tablero.casillas[35].ocupado && tablero.casillas[37].ocupado && tablero.casillas[42].ocupado && tablero.casillas[43].ocupado && tablero.casillas[44].ocupado && tablero.casillas[22].ocupado && tablero.casillas[24].ocupado && tablero.casillas[38].ocupado
							||
							tablero.casillas[37].numjugador == 2 && tablero.casillas[30].ocupado && tablero.casillas[36].ocupado && tablero.casillas[38].ocupado && tablero.casillas[44].ocupado && tablero.casillas[23].ocupado && tablero.casillas[35].ocupado && tablero.casillas[39].ocupado
							||
							tablero.casillas[38].numjugador == 2 && tablero.casillas[30].ocupado && tablero.casillas[31].ocupado && tablero.casillas[32].ocupado && tablero.casillas[37].ocupado && tablero.casillas[39].ocupado && tablero.casillas[44].ocupado && tablero.casillas[45].ocupado && tablero.casillas[46].ocupado && tablero.casillas[22].ocupado && tablero.casillas[24].ocupado && tablero.casillas[26].ocupado && tablero.casillas[36].ocupado && tablero.casillas[40].ocupado
							||
							tablero.casillas[39].numjugador == 2 && tablero.casillas[32].ocupado && tablero.casillas[38].ocupado && tablero.casillas[40].ocupado && tablero.casillas[46].ocupado && tablero.casillas[25].ocupado && tablero.casillas[37].ocupado && tablero.casillas[41].ocupado
							||
							tablero.casillas[40].numjugador == 2 && tablero.casillas[32].ocupado && tablero.casillas[33].ocupado && tablero.casillas[34].ocupado && tablero.casillas[39].ocupado && tablero.casillas[41].ocupado && tablero.casillas[46].ocupado && tablero.casillas[47].ocupado && tablero.casillas[48].ocupado && tablero.casillas[24].ocupado && tablero.casillas[26].ocupado && tablero.casillas[38].ocupado
							||
							tablero.casillas[41].numjugador == 2 && tablero.casillas[34].ocupado && tablero.casillas[40].ocupado && tablero.casillas[48].ocupado && tablero.casillas[27].ocupado && tablero.casillas[39].ocupado
							||
							tablero.casillas[42].numjugador == 2 && tablero.casillas[35].ocupado && tablero.casillas[36].ocupado && tablero.casillas[43].ocupado && tablero.casillas[28].ocupado && tablero.casillas[30].ocupado && tablero.casillas[44].ocupado
							||
							tablero.casillas[43].numjugador == 2 && tablero.casillas[36].ocupado && tablero.casillas[42].ocupado && tablero.casillas[44].ocupado && tablero.casillas[29].ocupado && tablero.casillas[45].ocupado
							||
							tablero.casillas[44].numjugador == 2 && tablero.casillas[36].ocupado && tablero.casillas[37].ocupado && tablero.casillas[38].ocupado && tablero.casillas[43].ocupado && tablero.casillas[45].ocupado && tablero.casillas[28].ocupado && tablero.casillas[30].ocupado && tablero.casillas[32].ocupado && tablero.casillas[42].ocupado && tablero.casillas[46].ocupado
							||
							tablero.casillas[45].numjugador == 2 && tablero.casillas[38].ocupado && tablero.casillas[44].ocupado && tablero.casillas[46].ocupado && tablero.casillas[31].ocupado && tablero.casillas[43].ocupado && tablero.casillas[47].ocupado 
							||
							tablero.casillas[46].numjugador == 2 && tablero.casillas[38].ocupado && tablero.casillas[39].ocupado && tablero.casillas[40].ocupado && tablero.casillas[45].ocupado && tablero.casillas[47].ocupado && tablero.casillas[30].ocupado && tablero.casillas[32].ocupado && tablero.casillas[34].ocupado && tablero.casillas[44].ocupado && tablero.casillas[48].ocupado
							||
							tablero.casillas[47].numjugador == 2 && tablero.casillas[40].ocupado && tablero.casillas[46].ocupado && tablero.casillas[48].ocupado && tablero.casillas[33].ocupado && tablero.casillas[45].ocupado
							||
							tablero.casillas[48].numjugador == 2 && tablero.casillas[40].ocupado && tablero.casillas[41].ocupado && tablero.casillas[47].ocupado && tablero.casillas[32].ocupado && tablero.casillas[34].ocupado && tablero.casillas[46].ocupado
						
							
					)
						{
							result = 1;
						}
				}//Fin tipotabl == 6
		return result;
	}


	public void inicializaAtributos()
	{
		//Damos los valores por defecto a los atributos de ZorraGansos
		
		dosColores = true;
		lInfoJug1.setText("Jugador: Gansos");
		lInfoJug2.setText("Jugador: Zorra");

	    
	    cuentaEmpezar = 0;
	    
	    
	    //Estos dos valores dependeran de lo que se de por entrada, pe omientras lo ponemos asi
	    numjugadores = 2; //Suponemos que tratamos solo con 2 (esto se pedira)
	    ////////////////////////
	    tipotabl = 1;
	    NumFicPat = 12;
	    ///////////////////
	    turno = 1; // turno 1 equivale a jugador 1
	    tiempo=new Tiempo();
	    flagSalto = false;
	    numsalto = 0; //Para saber porque salto vamos
	    seleccionada_posi = -1; //Guarda el indice i de la posicion seleccionada. Antes era marcado[0]
	 	seleccionada_posj = -1; //Guarda el indice j de la posicion seleccionada. Antes era marcado [1]
	    candidata_posi = -1; //Guarda el indice i de la posicion candidata. Antes era flagMarcado[0]
	    candidata_posj = -1; //Guarda el indice j de la posicion candidata. Antes era flagMarcado[1]
	    flag = false;	    
	    inicializaSaltos();
	    saltos[0] = -1;
	    numMovimientos = 0;
	    
	    contador1 = 0;
	    contador2 = 0;
	    repetido1 = new Sucesor();
	    repetido2 = new Sucesor();
	    
	    sal_borra[0] = -1;
	    nfiblan = 0;
	}
	
	public void reinicia() 
	{
		Panel p1, p2;
	    Checkbox cb1, cb2, cb3; //independent checkboxes
	    Checkbox cb4, cb5, cb6; //only one of these three can be selected
	    CheckboxGroup cbg;
	    JFrame ventana= new JFrame();
	    JPanel panel= new JPanel(); 

			tiempo.parar(true);
			inicializaAtributos();
			
			{
				Opciones tem= new Opciones(this);
				
		   		tem.mostrar("Partida nueva tablero");
		   		if(tem.boton1.getState() == true)
		   		{
		   			tipotabl = 1;
		   			tablero = new Tablero(tipotabl);
		   			NumFicPat = tablero.jugadores[0].numFichaTotal;
		   		}
		   		else
		   			if (tem.boton2.getState() == true)
		   			{
		   				tipotabl = 2;
			   			tablero = new Tablero(tipotabl);
			   			NumFicPat = tablero.jugadores[0].numFichaTotal;
		   			}
		   			else if (tem.boton3.getState() == true)
		   			{
		   				tipotabl = 3;
			   			tablero = new Tablero(tipotabl);
			   			NumFicPat = tablero.jugadores[0].numFichaTotal;
		   			}
		   			else if (tem.boton4.getState() == true)
		   			{
		   				tipotabl = 4;
			   			tablero = new Tablero(tipotabl);
			   			NumFicPat = tablero.jugadores[0].numFichaTotal;
		   			}
		   			else if (tem.boton5.getState() == true)
		   			{
		   				tipotabl = 5;
			   			tablero = new Tablero(tipotabl);
			   			NumFicPat = tablero.jugadores[0].numFichaTotal;
		   			}
		   			else if (tem.boton6.getState() == true)
		   			{
		   				tipotabl = 6;
			   			tablero = new Tablero(tipotabl);
			   			NumFicPat = tablero.jugadores[0].numFichaTotal;
		   			}
		   		/// hasta aquí la elección del tipo de tablero para jugador 0 (gansos)
		   		
		   			tem= new Opciones(this);
		   			
			   		tem.mostrar("Partida nueva controlJug1");
			   		tablero = new Tablero(tipotabl);
			   		
			   		if(tem.boton1.getState() == true)
			   		{
			   			tablero.jugadores[0].esPC = false; //jugador humano para patos
			   			botonJugador1.setIcon(USjug1);	//icono humano patos   		
			   		}
			   		else
			   		{
				   		botonJugador1.setIcon(PCjug1);
			   			tablero.jugadores[0].esPC = true; //los patos son PC
			   		
			   			//como es PC los patos, hay que elegir nivel y al elegir nivel, elegimos tambien la profundidad
			   			
			   			tem= new Opciones(this);
				   		tem.mostrar("Elige nivel");
				   		if(tem.boton1.getState() == true)
			   			{
				   			tablero.jugadores[0].setNivel(1); //Nivel Facil
				   			tablero.jugadores[0].setProfundidad(1); //Nivel de profundidad 1
				   			Random rand = new Random();
		                	int x = rand.nextInt(7);
		                	if (tipotabl == 1 || tipotabl == 4)
		                	{
			                	if (x < 4)
			                		tablero.jugadores[0].setHeuristica(1);
			                	else if (x >= 4 || x < 6 )
			                		tablero.jugadores[0].setHeuristica(2);
			                	else if (x == 6)
			                		tablero.jugadores[0].setHeuristica(3);
			                	else if (x == 7)
			                		tablero.jugadores[0].setHeuristica(4);
		                	}
		                	else if (tipotabl == 3 || tipotabl == 5)
		                	{
		                		if (x < 5)
		                			tablero.jugadores[0].setHeuristica(1);
		                		else if (x >= 5)
		                		{
		                			tablero.jugadores[0].setHeuristica(2);
		                		}
		                	}
			   			}
			   			else if(tem.boton2.getState() == true)
			   			{
			   				tablero.jugadores[0].setNivel(2); //Nivel Medio
			   				tablero.jugadores[0].setProfundidad(2); //Nivel de profundidad 2
			   				Random rand = new Random();
		                	int x = rand.nextInt(7);
		                	if (tipotabl == 1 || tipotabl == 4)
		                	{
			                	if (x < 4)
			                		tablero.jugadores[0].setHeuristica(1);
			                	else if (x >= 4 || x < 6 )
			                		tablero.jugadores[0].setHeuristica(2);
			                	else if (x == 6)
			                		tablero.jugadores[0].setHeuristica(3);
			                	else if (x == 7)
			                		tablero.jugadores[0].setHeuristica(4);
		                	}
		                	else if (tipotabl == 3 || tipotabl == 5)
		                	{
		                		if (x < 5)
		                			tablero.jugadores[0].setHeuristica(1);
		                		else if (x >= 5)
		                		{
		                			tablero.jugadores[0].setHeuristica(2);
		                		}
		                	}
			   			}
			   			if(tem.boton3.getState() == true)
			   			{
			   				tablero.jugadores[0].setNivel(3); //Nivel Dificil
			   				tablero.jugadores[0].setProfundidad(4); //Nivel de profundidad 4
			   				Random rand = new Random();
		                	int x = rand.nextInt(7);
		                	if (tipotabl == 1 || tipotabl == 4)
		                	{
			                	if (x < 4)
			                		tablero.jugadores[0].setHeuristica(1);
			                	else if (x >= 4 || x < 6 )
			                		tablero.jugadores[0].setHeuristica(2);
			                	else if (x == 6)
			                		tablero.jugadores[0].setHeuristica(3);
			                	else if (x == 7)
			                		tablero.jugadores[0].setHeuristica(4);
		                	}
		                	else if (tipotabl == 3 || tipotabl == 5)
		                	{
		                		if (x < 5)
		                			tablero.jugadores[0].setHeuristica(1);
		                		else if (x >= 5)
		                		{
		                			tablero.jugadores[0].setHeuristica(2);
		                		}
		                	}
			   				
			   			}
			   			if(tem.boton4.getState() == true)
			   			{
			   				tablero.jugadores[0].setNivel(4); //Nivel Aleatorio
			   				Random rand = new Random();
		                	int x = rand.nextInt(2);
		                	if (x==0)
		                	{
					   			tablero.jugadores[0].setProfundidad(1); //Nivel de profundidad 1
		                	}
		                	else if (x==1)
		                	{
				   				tablero.jugadores[0].setProfundidad(2); //Nivel de profundidad 2
		                	}
		                	else if (x==2)
		                	{
				   				tablero.jugadores[0].setProfundidad(4); //Nivel de profundidad 4
		                	}
		                	Random rand1 = new Random();
		                	int y = rand.nextInt(7);
		                	if (tipotabl == 1 || tipotabl == 4)
		                	{
			                	if (y < 4)
			                		tablero.jugadores[0].setHeuristica(1);
			                	else if (y >= 4 || y < 6 )
			                		tablero.jugadores[0].setHeuristica(2);
			                	else if (y == 6)
			                		tablero.jugadores[0].setHeuristica(3);
			                	else if (y == 7)
			                		tablero.jugadores[0].setHeuristica(4);
		                	}
		                	else if (tipotabl == 3 || tipotabl == 5)
		                	{
		                		if (y < 5)
			                		tablero.jugadores[0].setHeuristica(1);
			                	else if (y >= 5)
			                		tablero.jugadores[0].setHeuristica(2);
		                	}
	               		
			   			}
			   			
			   		
			   		}
			   		tem= new Opciones(this);
			   		tem.mostrar("Partida nueva controlJug2");
			   		
			   		if(tem.boton1.getState() == true)
			   		{
			   			tablero.jugadores[1].esPC = false; 
			   			botonJugador2.setIcon(USjug2);	   		
			   		}
			   		else
			   		{
			   			tablero.jugadores[1].esPC = true;
			   			botonJugador2.setIcon(PCjug2);
			   			//botonJugador2.setIcon(PCjug2);
			   			tem= new Opciones(this);
				   		tem.mostrar("Elige nivel");
				   		if(tem.boton1.getState() == true)
			   			{
				   			tablero.jugadores[1].setNivel(1); //Nivel Bajo
				   			tablero.jugadores[1].setProfundidad(1); //Nivel de profundidad 1
			   			}
			   			else if(tem.boton2.getState() == true)
			   			{
			   				tablero.jugadores[1].setNivel(2); //Nivel Medio
			   				tablero.jugadores[1].setProfundidad(3); //Nivel de profundidad 3
			   			}
			   			if(tem.boton3.getState() == true)
			   			{
			   				tablero.jugadores[1].setNivel(3); //Nivel Dificil
			   				tablero.jugadores[1].setProfundidad(4); //Nivel de profundidad 4
			   			}
			   			if(tem.boton4.getState() == true)
			   			{
			   				tablero.jugadores[1].setNivel(4); //Nivel Aleatorio
			   				Random rand = new Random();
		                	int x = rand.nextInt(2);
		                	if (x==0)
		                	{
					   			tablero.jugadores[1].setProfundidad(1); //Nivel de profundidad 1
		                	}
		                	else if (x==1)
		                	{
				   				tablero.jugadores[1].setProfundidad(3); //Nivel de profundidad 3
		                	}
		                	else if (x==2)
		                	{
				   				tablero.jugadores[1].setProfundidad(4); //Nivel de profundidad 4
		                	}
			   			}
			   		
			   		
			  //tratamos aqui quien controla al jugador 2
			   		}
		   			tem= new Opciones(this);
		   			tem.mostrar("Partida nueva turno2jug");
		   			
		   			if(tem.boton1.getState() == true) //Comienza turno el jugador 1
		   			{
		   				turno = 1;
		   			}
		   			else //Comienza turno el jugador 2
		   			{
		   				turno =2;
		   			}
		   		}
			
	  
	        //Refrescamos los paneles de informacion de la derecha
	        actualizaPanelTurnos();
	        lTurno.setText("Turno: Jugador "+turno);
	        lAviso.setText("Se inicia una nueva partida");
	        
	        update(getGraphics());
	        
	        setLayout(null);
	        setResizable(false);
	        System.out.println("NumHeuuuuuuuuuuuu" + tablero.jugadores[0].numHeuristica);
	}



//////////////////////////////////////////////////////////////////////////

//para ver si la zorra salta
public int distancia(int a, int b)
{
    return Cinco_restri.distancia[a][b];
}

public int Xdistancia(int a, int b)
{
    return SieteX_restri.distancia[a][b];
}

public int Cdistancia(int a, int b)
{
	return Cruz_restri.distancia[a][b];
}

public int SRdistancia(int a,int b)
{
	return Cinco.distancia[a][b];
}

public int SRCdistancia(int a, int b)
{
	return Cruz.distancia[a][b];
}
public int SRXdistancia(int a, int b)
{
    return SieteX.distancia[a][b];
}

public int Val_abs (int i)
{
	if (i >= 0)
		return i;
	else
		return -i;
}

public int funcion_elimina5x5 (int posterior, int anterior)
{
	int pos_d, ant_d, pos_m, ant_m;
	
	pos_d = posterior/5;
	ant_d = anterior/5;
	pos_m = posterior%5;
	ant_m = anterior%5;
	
	if (pos_d == ant_d)
	{
		//System.out.println ("Javier " + pos_d + " " + Val_abs(ant_m - pos_m));
		return asociaCasilla((Val_abs(ant_m + pos_m))/2, pos_d);
	}
	
	if (ant_m == pos_m)
	{
		//System.out.println (pos_m + " " + Val_abs(ant_d - pos_d));
		return asociaCasilla(ant_m, (Val_abs(ant_d + pos_d))/2);
	}
	
	switch (posterior)
	{
	case 0:
		if (anterior == 12)
			return 6;
		
	case 1:
		if (anterior == 13)
			return 7;
	case 2:
		if (anterior == 14)
			return 8;
		if (anterior == 10)
			return 6;
	case 3:
		if (anterior == 11)
			return 7;
	case 4:
		if (anterior == 12)
			return 8;
	case 5:
		if (anterior == 17)
			return 11;
	case 6:
		if (anterior == 18)
			return 12;
	case 7:
		if (anterior == 19)
			return 13;
		if (anterior == 15)
			return 11;
	case 8:
		if (anterior == 16)
			return 12;
	case 9:
		if (anterior == 17)
			return 13;
	case 10:
		if (anterior == 2)
			return 6;
		if (anterior == 22)
			return 16;
	case 11:
		if (anterior == 3)
			return 7;
		if (anterior == 23)
			return 17;
	case 12:
		if (anterior == 0)
			return 6;
		if (anterior == 4)
			return 8;
		if (anterior == 20)
			return 16;
		if (anterior == 24)
			return 18;
	case 13:
		if (anterior == 1)
			return 7;
		if (anterior == 21)
			return 17;
	case 14:
		if (anterior == 2)
			return 8;
		if (anterior == 22)
			return 18;
	case 15:
		if (anterior == 7)
			return 11;
	case 16:
		if (anterior == 8)
			return 12;
	case 17:
		if (anterior == 5)
			return 11;
		if (anterior == 9)
			return 13;
	case 18:
		if (anterior == 6)
			return 12;
	case 19:
		if (anterior == 7)
			return 13;
	case 20:
		if (anterior == 12)
			return 16;
	case 21:
		if (anterior == 13)
			return 17;
	case 22:
		if (anterior == 4)
			return 18;
		if (anterior == 10)
			return 16;
	case 23:
		if (anterior == 11)
			return 17;
	case 24:
		if (anterior == 12)
			return 18;
		default:
			break;
	}
	return 0;
}

public int funcion_elimina7x7 (int posterior, int anterior)
{
	int pos_d, ant_d, pos_m, ant_m;
	
	pos_d = posterior/7;
	ant_d = anterior/7;
	pos_m = posterior%7;
	ant_m = anterior%7;
	
	if (pos_d == ant_d)
	{
		//System.out.println ("Javier " + pos_d + " " + Val_abs(ant_m - pos_m));
		return XasociaCasilla((Val_abs(ant_m + pos_m))/2, pos_d);
	}
	
	if (ant_m == pos_m)
	{
		//System.out.println (pos_m + " " + Val_abs(ant_d - pos_d));
		return XasociaCasilla(ant_m, (Val_abs(ant_d + pos_d))/2);
	}
	
	switch (posterior)
	{
	case 0:
		if (anterior == 16)
			return 8;
		
	case 1:
		if (anterior == 17)
			return 9;
	case 2:
		if (anterior == 14)
			return 8;
		if (anterior == 18)
			return 10;
	case 3:
		if (anterior == 15)
			return 9;
		if (anterior == 19)
			return 11;
	case 4:
		if (anterior == 16)
			return 10;
		if (anterior == 20)
			return 12;
	case 5:
		if (anterior == 17)
			return 11;
	case 6:
		if (anterior == 18)
			return 12;
	case 7:
		if (anterior == 23)
			return 15;
	case 8:
		if (anterior == 24)
			return 16;
	case 9:
		if (anterior == 21)
			return 15;
		if (anterior == 25)
			return 17;
	case 10:
		if (anterior == 22)
			return 16;
		if (anterior == 26)
			return 18;
	case 11:
		if (anterior == 27)
			return 19;
		if (anterior == 23)
			return 17;
	case 12:
		if (anterior == 24)
			return 18;
	case 13:
		if (anterior == 25)
			return 19;
	case 14:
		if (anterior == 30)
			return 22;
		if (anterior == 2)
			return 8;
	case 15:
		if (anterior == 31)
			return 23;
		if (anterior == 3)
			return 9;
	case 16:
		if (anterior == 0)
			return 8;
		if (anterior == 4)
			return 10;
		if (anterior == 28)
			return 22;
		if (anterior == 32)
			return 24;
	case 17:
		if (anterior == 1)
			return 9;
		if (anterior == 5)
			return 11;
		if (anterior == 29)
			return 23;
		if (anterior == 33)
			return 25;
	case 18:
		if (anterior == 6)
			return 12;
		if (anterior == 2)
			return 10;
		if (anterior == 30)
			return 24;
		if (anterior == 34)
			return 26;
	case 19:
		if (anterior == 3)
			return 11;
		if (anterior == 31)
			return 25;
	case 20:
		if (anterior == 4)
			return 12;
		if (anterior == 32)
			return 26;
	case 21:
		if (anterior == 9)
			return 15;
		if (anterior == 37)
			return 29;
	case 22:
		if (anterior == 38)
			return 30;
		if (anterior == 10)
			return 16;
	case 23:
		if (anterior == 7)
			return 15;
		if (anterior == 11)
			return 17;
		if (anterior == 35)
			return 29;
		if (anterior == 39)
			return 31;
	case 24:
		if (anterior == 8)
			return 16;
		if (anterior == 12)
			return 18;
		if (anterior == 36)
			return 30;
		if (anterior == 40)
			return 32;
	case 25:
		if (anterior == 9)
			return 17;
		if (anterior == 13)
			return 19;
		if (anterior == 37)
			return 31;
		if (anterior == 41)
			return 33;
	case 26:
		if (anterior == 10)
			return 18;
		if (anterior == 38)
			return 32;
	case 27:
		if (anterior == 11)
			return 19;
		if (anterior == 39)
			return 33;
	case 28:
		if (anterior == 16)
			return 22;
		if (anterior == 44)
			return 36;
	case 29:
		if (anterior == 17)
			return 23;
		if (anterior == 45)
			return 37;
	case 30:
		if (anterior == 14)
			return 22;
		if (anterior == 18)
			return 24;
		if (anterior == 42)
			return 36;
		if (anterior == 46)
			return 38;
	case 31:
		if (anterior == 15)
			return 23;
		if (anterior == 19)
			return 25;
		if (anterior == 43)
			return 37;
		if (anterior == 47)
			return 39;
	case 32:
		if (anterior == 48)
			return 40;
		if (anterior == 20)
			return 26;
		if (anterior == 44)
			return 38;
		if (anterior == 16)
			return 24;
	case 33:
		if (anterior == 17)
			return 25;
		if (anterior == 45)
			return 39;
	case 34:
		if (anterior == 18)
			return 26;
		if (anterior == 46)
			return 40;
	case 35:
		if (anterior == 23)
			return 29;
	case 36:
		if (anterior == 24)
			return 30;
	case 37:
		if (anterior == 25)
			return 31;
		if (anterior == 21)
			return 29;
	case 38:
		if (anterior == 26)
			return 32;
		if (anterior == 22)
			return 30;
	case 39:
		if (anterior == 23)
			return 31;
		if (anterior == 27)
			return 33;
	case 40:
		if (anterior == 24)
			return 32;
	case 41:
		if (anterior == 25)
			return 33;
	case 42:
		if (anterior == 30)
			return 36;
	case 43:
		if (anterior == 31)
			return 37;
		if (anterior == 35)
			return 29;
		if (anterior == 39)
			return 31;
	case 44:
		if (anterior == 28)
			return 36;
		if (anterior == 32)
			return 38;
	case 45:
		if (anterior == 29)
			return 37;
		if (anterior == 33)
			return 39;
	case 46:
		if (anterior == 30)
			return 38;
		if (anterior == 34)
			return 40;
	case 47:
		if (anterior == 31)
			return 39;
	case 48:
		if (anterior == 32)
			return 40;
		default:
			break;
	}
	return 0;
}

void mover_pc ()
{
		//juega PC
		System.out.println("PrincipioMoverPC-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ");
   
		auxtablero = tablero;
		int quitacasilla;
		int quitaficha;
		int aux;
		int numficha;
		int numcasilla_aux;
		int numjug=turno;
		int fichaelimina = 0;
		numMovimientos++;
		lNumMovimientos.setText("Nº Movmientos: " + numMovimientos);
		
		int fic=0;
		int b;
		Casilla casillaaux;
		boolean fin = false;
		
		if (tipotabl == 1 || tipotabl == 4)
		{
			//minimax = new MiniMax(auxtablero, turno, auxtablero.jugadores[turno-1].nivel, auxtablero.jugadores[turno-1].numFichaTotal,auxtablero.jugadores[turno-1].distanciaTotal,tipotabl);
			minimax = new MiniMax(auxtablero, turno, auxtablero.jugadores[turno-1].nivel, auxtablero.jugadores[turno-1].numFichaTotal,tipotabl,repetido1,repetido2,contador1,contador2,auxtablero.jugadores[turno-1].numHeuristica);
			actual = new Sucesores(0, auxtablero, turno, turno, auxtablero.jugadores[turno-1].nivelProfundidad, new ProfundidadYpeso(-9999999, -9999999), auxtablero.jugadores[turno-1].numHeuristica,tipotabl);
			if (turno == 1)
	    	{   
	    		//actual.crearLista(turno,NumFicPat,tipotabl);
	    		actual.crearLista(turno,auxtablero.jugadores[turno - 1].numFichaTotal,tipotabl);
	    		//elegido es un sucesor
	    		elegido = minimax.decisionMiniMax(actual, auxtablero.jugadores[turno-1].nivelProfundidad, turno);
	    		
	    		if (numMovimientos == 1)
	    		{
	    			repetido1 = elegido;
	    		}
	    		if (numMovimientos > 2)
	    		{
	    			if (repetido1.fichaMov == elegido.fichaMov && repetido1.posAnterior == elegido.posPosterior
	    					&& repetido1.posPosterior == elegido.posAnterior)
	    			{
	    				contador1++;
	    			}
	    			else
	    				contador1 = 0;
	    			repetido1 = elegido;
	    		}
	    		System.out.println("contador1: " + contador1);
	    		System.out.println("elegido " + elegido.fichaMov + "-" + elegido.posAnterior + "-" + elegido.posPosterior);
	    		System.out.println("repetido1" + repetido1.fichaMov + "-" + repetido1.posPosterior + "-" + repetido1.posAnterior);
	    		
	    		if (elegido.fichaMov != -1)
		        {
	            	System.out.println("fiMov: " + elegido.fichaMov + " ant: " + elegido.posAnterior + " pos: " + elegido.posPosterior);
		           	//Dibujarla pieza
		        	dibujaCandidata(elegido.posPosterior%5,elegido.posPosterior/5);
		        	dibujaSeleccion(tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla%5, tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla/5);
		           
		        	parpadeo();
			        parpadeo();
			        borrarCuadro(tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla%5, tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla/5);
			        
			        pintarPieza(turno, elegido.posPosterior/5, elegido.posPosterior%5, true);
					
			        int numcasilla = tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla;
			       // System.out.println("pos:" + elegido.posPosterior + " ant:" + elegido.posAnterior + " fmv:" + elegido.fichaMov + " ncas:" + numcasilla);

			        numjug = turno;
					
			        tablero.casillas[elegido.posPosterior] = new Casilla (elegido.fichaMov,turno,elegido.posPosterior);
			        //Actualizamos los valores de la casilla candidata 		
					tablero.casillas[elegido.posPosterior].colocarFichaEnCandidata(elegido.fichaMov, numjug);
					//Actualizamos las caracteristicas de la casilla hacia la que se mueve la ficha 		
					//tablero.jugadores[numjug - 1].fichas[elegido.fichaMov%5].actualizarCasillaFicha(elegido.posPosterior);
					tablero.jugadores[numjug - 1].fichas[elegido.fichaMov].actualizarCasillaFicha(elegido.posPosterior);
					////////////////////////////////////////////////////////////////////////////////////
					
					////////////////////
					tablero.casillas[numcasilla].quitarFichaEnSeleccionada();
					//Actualizamos los valores de la casilla seleccionada 		
					tablero.casillas[numcasilla] = new Casilla (numcasilla);
					//Actualizamos las caraceristicas del movimiento realizado por el jugador que mueva		
					tablero.jugadores[numjug - 1].movimientos ++; 
					tablero.jugadores[numjug - 1].ultimaFicha = elegido.fichaMov;
					tablero.jugadores[numjug - 1].ultimaCasilla = numcasilla;
					
					update(getGraphics());
				//	tablero.jugadores[numjug - 1].calcularDistanciaTotalPuntoCentral(NumFicPat);
					
		        }
	    	}
	    	if (turno == 2)
	    	{
	    		actual.crearLista(turno,auxtablero.jugadores[turno -1].numFichaTotal,tipotabl);
	    		//elegido es un sucesor
	            elegido = minimax.decisionMiniMax(actual, auxtablero.jugadores[turno-1].nivelProfundidad, turno);
	            if (numMovimientos == 1)
	    		{
	    			repetido2 = elegido;
	    		}
	    		if (numMovimientos > 2)
	    		{
	    			if (repetido2.fichaMov == elegido.fichaMov && repetido2.posAnterior == elegido.posPosterior
	    					&& repetido2.posPosterior == elegido.posAnterior)
	    			{
	    				contador2++;
	    			}
	    			else
	    				contador2 = 0;
	    			repetido2 = elegido;
	    		}
	    		System.out.println("contador2: " + contador2);
	    		System.out.println("elegido " + elegido.fichaMov + "-" + elegido.posAnterior + "-" + elegido.posPosterior);
	    		System.out.println("repetido" + repetido2.fichaMov + "-" + repetido2.posPosterior + "-" + repetido2.posAnterior);
	    		
	            if (elegido.fichaMov != -1)
		        {
		            //Dibujarla pieza
		            dibujaCandidata(elegido.posPosterior%5,elegido.posPosterior/5);
		            //Esto haria lo mismo que con elegido.fichamov
		            //dibujaSeleccion(tablero.jugadores[turno-1].fichas[12].numcasilla%5, tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla/5);
		            dibujaSeleccion(tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla%5, tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla/5);
		        
			        parpadeo();
			        parpadeo();
			        
			        if (SRdistancia(elegido.posAnterior,elegido.posPosterior) > 1 && tipotabl == 1)
			        {
			        	elimina = funcion_elimina5x5 (elegido.posPosterior,elegido.posAnterior);
			        	elimina = elegido.fichacomida;
			        	System.out.println("ELIMINA " + elimina);
				        //borra la ficha del zorro. posAnterior.
			        	borrarCuadro(tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla%5, tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla/5);
		
			        	fichaelimina = tablero.casillas[elimina].numficha;
			        	//borra el pato comido.
			        	borrarCuadro(tablero.jugadores[turno-2].fichas[fichaelimina].numcasilla%5, tablero.jugadores[turno-2].fichas[fichaelimina].numcasilla/5);
			        	
			        	quitacasilla = tablero.jugadores[turno-2].fichas[fichaelimina].numcasilla;
						numjug = turno;
						System.out.println("quitacasilla: " + quitacasilla + "elimina: " + elimina + "fichaelimina: " + fichaelimina);
						
						//Nuevo
						tablero.casillas[quitacasilla] = new Casilla(quitacasilla);
						
						//quita del pato del tablero.
						tablero.casillas[quitacasilla].quitarFichaEnSeleccionada();
						
						tablero.jugadores[0].fichas[fichaelimina].desactivarFicha();
						NumFicPat--;
						update(getGraphics());

			        }
			        if (distancia(elegido.posAnterior,elegido.posPosterior) > 1 && tipotabl == 4)
			        {
			        	elimina = funcion_elimina5x5 (elegido.posPosterior,elegido.posAnterior);
			        	elimina = elegido.fichacomida;
			        	System.out.println("ELIMINA " + elimina);
				        //borra la ficha del zorro. posAnterior.
			        	borrarCuadro(tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla%5, tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla/5);
		
			        	fichaelimina = tablero.casillas[elimina].numficha;
			        	//borra el pato comido.
			        	borrarCuadro(tablero.jugadores[turno-2].fichas[fichaelimina].numcasilla%5, tablero.jugadores[turno-2].fichas[fichaelimina].numcasilla/5);
			        	
			        	quitacasilla = tablero.jugadores[turno-2].fichas[fichaelimina].numcasilla;
						numjug = turno;
						System.out.println("quitacasilla: " + quitacasilla + "elimina: " + elimina + "fichaelimina: " + fichaelimina);
						
						//Nuevo
						tablero.casillas[quitacasilla] = new Casilla(quitacasilla);
						
						//quita del pato del tablero.
						tablero.casillas[quitacasilla].quitarFichaEnSeleccionada();
						
						tablero.jugadores[0].fichas[fichaelimina].desactivarFicha();
						NumFicPat--;
						update(getGraphics());

			        }
						
			        //pinta la pieza del zorro en posPosterior.
			        pintarPieza(turno, elegido.posPosterior/5, elegido.posPosterior%5, true);
						
					int numcasilla = tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla;
					tablero.casillas[elegido.posPosterior] = new Casilla (elegido.fichaMov,turno,elegido.posPosterior);
						
					//Actualizamos los valores de la casilla candidata 		
					tablero.casillas[elegido.posPosterior].colocarFichaEnCandidata(elegido.fichaMov, numjug);
					//Actualizamos las caracteristicas de la casilla hacia la que se mueve la ficha 		
					System.out.println("fichamovvvvvvvvvv" + elegido.fichaMov);
					//tablero.jugadores[numjug - 1].fichas[elegido.fichaMov%5].actualizarCasillaFicha(elegido.posPosterior);
					
					tablero.jugadores[numjug - 1].fichas[elegido.fichaMov].actualizarCasillaFicha(elegido.posPosterior);
					//Actualizamos los valores de la casilla seleccionada 		
					tablero.casillas[numcasilla] = new Casilla (numcasilla);
					
					tablero.casillas[numcasilla].quitarFichaEnSeleccionada();
					
					//Actualizamos las caraceristicas del movimiento realizado por el jugador que mueva		
					tablero.jugadores[numjug - 1].movimientos ++; 
					tablero.jugadores[numjug - 1].ultimaFicha = elegido.fichaMov;
					tablero.jugadores[numjug - 1].ultimaCasilla = numcasilla; 
					update(getGraphics());
						
				//	tablero.jugadores[numjug - 1].calcularDistanciaTotalPuntoCentral(1);//siempre hay un zorro
				}
	            
	    	}
	    	
			lAviso.setText("Se ha movido la ficha "+elegido.fichaMov%5+" del jugador "+
					numjug+" a la casilla "+elegido.posPosterior);
			turno = actualizaTurno(); //Cada vez que se mueva se actualiza el turno
			lTurno.setText("Turno: Jugador "+turno);
					
			actualizaPanelTurnos();
			//update(getGraphics());
				
			if(compruebaGanador()!=0)// || numMovimientos == totalMovimientos)
			{
				detenerJuego = true;
				numMovimientos = 0;
				return;
			}
			if(!detenerJuego && tablero.jugadores[turno-1].esPC)
			{
				mover_pc();
			}
			
		}
		else if (tipotabl == 2 || tipotabl == 6)
		{
			//minimax = new MiniMax(auxtablero, turno, auxtablero.jugadores[turno-1].nivel, auxtablero.jugadores[turno-1].numFichaTotal,auxtablero.jugadores[turno-1].distanciaTotal,tipotabl);
			minimax = new MiniMax(auxtablero, turno, auxtablero.jugadores[turno-1].nivel, auxtablero.jugadores[turno-1].numFichaTotal,tipotabl,repetido1,repetido2,contador1,contador2,auxtablero.jugadores[turno-1].numHeuristica);

			actual = new Sucesores(0, auxtablero, turno, turno, auxtablero.jugadores[turno-1].nivelProfundidad, new ProfundidadYpeso(-9999999, -9999999), auxtablero.jugadores[turno-1].numHeuristica,tipotabl);
			//actual = new Sucesores(0, tablero, turno, turno, tablero.jugadores[turno-1].nivelProfundidad, new ProfundidadYpeso(-9999999, -9999999), tablero.jugadores[turno-1].numHeuristica,tipotabl);
	    	
	    	if (turno == 1)
	    	{    	
	    		actual.crearLista(turno,auxtablero.jugadores[turno - 1].numFichaTotal,tipotabl);
	    		//elegido es un sucesor
	    		elegido = minimax.decisionMiniMax(actual, auxtablero.jugadores[turno-1].nivelProfundidad, turno);
	    		
	    		if (numMovimientos == 1)
	    		{
	    			repetido1 = elegido;
	    		}
	    		if (numMovimientos > 2)
	    		{
	    			if (repetido1.fichaMov == elegido.fichaMov && repetido1.posAnterior == elegido.posPosterior
	    					&& repetido1.posPosterior == elegido.posAnterior)
	    			{
	    				contador1++;
	    			}
	    			else
	    				contador1 = 0;
	    			repetido1 = elegido;
	    		}
	    		System.out.println("contador1: " + contador1);
	    		System.out.println("elegido " + elegido.fichaMov + "-" + elegido.posAnterior + "-" + elegido.posPosterior);
	    		System.out.println("repetido1" + repetido1.fichaMov + "-" + repetido1.posPosterior + "-" + repetido1.posAnterior);
	    		
	    		
	    		if (elegido.fichaMov != -1)
		        {
		           	//Dibujarla pieza
		        	dibujaCandidata(elegido.posPosterior%7,elegido.posPosterior/7);
		        	dibujaSeleccion(tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla%7, tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla/7);
		            
		        	parpadeo();
			        parpadeo();
			        
			        borrarCuadro(tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla%7, tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla/7);
			        
			        pintarPieza(turno, elegido.posPosterior/7, elegido.posPosterior%7, true);
					
			        int numcasilla = tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla;
					
			        numjug = turno;
					
			        tablero.casillas[elegido.posPosterior] = new Casilla (elegido.fichaMov,turno,elegido.posPosterior);
					
			        //Actualizamos los valores de la casilla candidata 		
					tablero.casillas[elegido.posPosterior].colocarFichaEnCandidata(elegido.fichaMov, numjug);
					
					//Actualizamos las caracteristicas de la casilla hacia la que se mueve la ficha 		
					//tablero.jugadores[numjug - 1].fichas[elegido.fichaMov%5].actualizarCasillaFicha(elegido.posPosterior);
					tablero.jugadores[numjug - 1].fichas[elegido.fichaMov].actualizarCasillaFicha(elegido.posPosterior);
					
					tablero.casillas[numcasilla].quitarFichaEnSeleccionada();
					//Actualizamos los valores de la casilla seleccionada 		
					tablero.casillas[numcasilla] = new Casilla (numcasilla);
				
					//Actualizamos las caraceristicas del movimiento realizado por el jugador que mueva		
					tablero.jugadores[numjug - 1].movimientos ++; 
					tablero.jugadores[numjug - 1].ultimaFicha = elegido.fichaMov;
					tablero.jugadores[numjug - 1].ultimaCasilla = numcasilla;
					update(getGraphics());
					//tablero.jugadores[numjug - 1].calcularDistanciaTotalPuntoCentral(NumFicPat);
				}
	    	}
	    	if (turno == 2)
	    	{
	    		actual.crearLista(turno,auxtablero.jugadores[turno -1].numFichaTotal,tipotabl);
	    		//elegido es un sucesor
	            elegido = minimax.decisionMiniMax(actual, auxtablero.jugadores[turno-1].nivelProfundidad, turno);
	            System.out.println("aquipara " + elegido.fichaMov ); 
	            if (numMovimientos == 1)
	    		{
	    			repetido2 = elegido;
	    		}
	    		if (numMovimientos > 2)
	    		{
	    			if (repetido2.fichaMov == elegido.fichaMov && repetido2.posAnterior == elegido.posPosterior
	    					&& repetido2.posPosterior == elegido.posAnterior)
	    			{
	    				contador2++;
	    			}
	    			else
	    				contador2 = 0;
	    			repetido2 = elegido;
	    		}
	    		System.out.println("contador2: " + contador2);
	    		System.out.println("elegido " + elegido.fichaMov + "-" + elegido.posAnterior + "-" + elegido.posPosterior);
	    		System.out.println("repetido" + repetido2.fichaMov + "-" + repetido2.posPosterior + "-" + repetido2.posAnterior);
	    		
	            if (elegido.fichaMov != -1)
		        {
		            //Dibujarla pieza
		            dibujaCandidata(elegido.posPosterior%7,elegido.posPosterior/7);
		        	dibujaSeleccion(tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla%7, tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla/7);
		        
			        parpadeo();
			        parpadeo();
			        
			        if (SRXdistancia(elegido.posAnterior,elegido.posPosterior) > 1 && tipotabl == 2)
			        {
			        	
			        	elimina = funcion_elimina7x7 (elegido.posPosterior,elegido.posAnterior);
			        	
			        	elimina = elegido.fichacomida;
			        	
			        	borrarCuadro(tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla%7, tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla/7);
		
			        	fichaelimina = tablero.casillas[elimina].numficha;
			        	//borra el pato comido.
			        	borrarCuadro(tablero.jugadores[turno-2].fichas[fichaelimina].numcasilla%7, tablero.jugadores[turno-2].fichas[fichaelimina].numcasilla/7);
			        	
			        	quitacasilla = tablero.jugadores[turno-2].fichas[fichaelimina].numcasilla;
						numjug = turno;
						System.out.println("quitacasilla: " + quitacasilla + "elimina: " + elimina + "fichaelimina: " + fichaelimina);
						//Nuevo
						tablero.casillas[quitacasilla] = new Casilla(quitacasilla);
						
						//quita del pato del tablero.
						tablero.casillas[quitacasilla].quitarFichaEnSeleccionada();
						
						tablero.jugadores[0].fichas[fichaelimina].desactivarFicha();
						NumFicPat--;
						update(getGraphics());
					}
			        if (Xdistancia(elegido.posAnterior,elegido.posPosterior) > 1 && tipotabl == 6)
			        {
			        	
			        	elimina = funcion_elimina7x7 (elegido.posPosterior,elegido.posAnterior);
			        	
			        	elimina = elegido.fichacomida;
			        	
			        	borrarCuadro(tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla%7, tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla/7);
		
			        	fichaelimina = tablero.casillas[elimina].numficha;
			        	//borra el pato comido.
			        	borrarCuadro(tablero.jugadores[turno-2].fichas[fichaelimina].numcasilla%7, tablero.jugadores[turno-2].fichas[fichaelimina].numcasilla/7);
			        	
			        	quitacasilla = tablero.jugadores[turno-2].fichas[fichaelimina].numcasilla;
						numjug = turno;
						System.out.println("quitacasilla: " + quitacasilla + "elimina: " + elimina + "fichaelimina: " + fichaelimina);
						//Nuevo
						tablero.casillas[quitacasilla] = new Casilla(quitacasilla);
						
						//quita del pato del tablero.
						tablero.casillas[quitacasilla].quitarFichaEnSeleccionada();
						
						tablero.jugadores[0].fichas[fichaelimina].desactivarFicha();
						NumFicPat--;
						update(getGraphics());
					}
						pintarPieza(turno, elegido.posPosterior/7, elegido.posPosterior%7, true);
						
						int numcasilla = tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla;
						
						tablero.casillas[elegido.posPosterior] = new Casilla (elegido.fichaMov,turno,elegido.posPosterior);
						//Actualizamos los valores de la casilla candidata 		
						tablero.casillas[elegido.posPosterior].colocarFichaEnCandidata(elegido.fichaMov, numjug);
						//Actualizamos las caracteristicas de la casilla hacia la que se mueve la ficha 		
						//tablero.jugadores[numjug - 1].fichas[elegido.fichaMov%7].actualizarCasillaFicha(elegido.posPosterior);
						tablero.jugadores[numjug - 1].fichas[elegido.fichaMov].actualizarCasillaFicha(elegido.posPosterior);
						//Actualizamos los valores de la casilla seleccionada 		
						tablero.casillas[numcasilla] = new Casilla (numcasilla);
						tablero.casillas[numcasilla].quitarFichaEnSeleccionada();

						//Actualizamos las caraceristicas del movimiento realizado por el jugador que mueva		
						tablero.jugadores[numjug - 1].movimientos ++; 
						tablero.jugadores[numjug - 1].ultimaFicha = elegido.fichaMov;
						tablero.jugadores[numjug - 1].ultimaCasilla = numcasilla; 
						update(getGraphics());
						//tablero.jugadores[numjug - 1].calcularDistanciaTotalPuntoCentral(1);//siempre hay un zorro
					}
	    	}
	    	
			lAviso.setText("Se ha movido la ficha "+elegido.fichaMov%7+" del jugador "+
					numjug+" a la casilla "+elegido.posPosterior);
			turno = actualizaTurno(); //Cada vez que se mueva se actualiza el turno
			lTurno.setText("Turno: Jugador "+turno);
					
			actualizaPanelTurnos();
			//update(getGraphics());
			
			if(compruebaGanador()!=0 || numMovimientos == totalMovimientos)
			{
				detenerJuego = true;
				numMovimientos = 0;
				return;
			}
			if(!detenerJuego && tablero.jugadores[turno-1].esPC)
			{
				mover_pc();
			}
			
		}
		else if (tipotabl == 3 || tipotabl == 5)
		{
			//minimax = new MiniMax(auxtablero, turno, auxtablero.jugadores[turno-1].nivel, auxtablero.jugadores[turno-1].numFichaTotal,auxtablero.jugadores[turno-1].distanciaTotal,tipotabl);
			minimax = new MiniMax(auxtablero, turno, auxtablero.jugadores[turno-1].nivel, auxtablero.jugadores[turno-1].numFichaTotal,tipotabl,repetido1,repetido2,contador1,contador2,auxtablero.jugadores[turno-1].numHeuristica);

			actual = new Sucesores(0, auxtablero, turno, turno, auxtablero.jugadores[turno-1].nivelProfundidad, new ProfundidadYpeso(-9999999, -9999999), auxtablero.jugadores[turno-1].numHeuristica,tipotabl);
			
			if (turno == 1)
	    	{    		
	    		//actual.crearLista(turno,NumFicPat,tipotabl);
	    		actual.crearLista(turno,auxtablero.jugadores[turno - 1].numFichaTotal,tipotabl);
	    		//elegido es un sucesor
	    		elegido = minimax.decisionMiniMax(actual, auxtablero.jugadores[turno-1].nivelProfundidad, turno);
	    		if (numMovimientos == 1)
	    		{
	    			repetido1 = elegido;
	    		}
	    		if (numMovimientos > 2)
	    		{
	    			if (repetido1.fichaMov == elegido.fichaMov && repetido1.posAnterior == elegido.posPosterior
	    					&& repetido1.posPosterior == elegido.posAnterior)
	    			{
	    				contador1++;
	    			}
	    			else
	    				contador1 = 0;
	    			repetido1 = elegido;
	    		}
	    		System.out.println("contador1: " + contador1);
	    		System.out.println("elegido " + elegido.fichaMov + "-" + elegido.posAnterior + "-" + elegido.posPosterior);
	    		System.out.println("repetido1" + repetido1.fichaMov + "-" + repetido1.posPosterior + "-" + repetido1.posAnterior);
	    		
	    		if (elegido.fichaMov != -1)
		        {
		           	//Dibujarla pieza
		        	dibujaCandidata(elegido.posPosterior%7,elegido.posPosterior/7);
		        	dibujaSeleccion(tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla%7, tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla/7);
		            
		        	parpadeo();
			        parpadeo();
			        
			        borrarCuadro(tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla%7, tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla/7);
			       
			        pintarPieza(turno, elegido.posPosterior/7, elegido.posPosterior%7, true);
					
			        int numcasilla = tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla;
					
			        numjug = turno;
					
			        tablero.casillas[elegido.posPosterior] = new Casilla (elegido.fichaMov,turno,elegido.posPosterior);
					//Actualizamos los valores de la casilla candidata 		
					tablero.casillas[elegido.posPosterior].colocarFichaEnCandidata(elegido.fichaMov, numjug);
					//Actualizamos las caracteristicas de la casilla hacia la que se mueve la ficha 		
					//tablero.jugadores[numjug - 1].fichas[elegido.fichaMov%5].actualizarCasillaFicha(elegido.posPosterior);
					tablero.jugadores[numjug - 1].fichas[elegido.fichaMov].actualizarCasillaFicha(elegido.posPosterior);
					////////////////////////////////////////////////////////////////////////////////////
					
					////////////////////
					tablero.casillas[numcasilla].quitarFichaEnSeleccionada();
					//Actualizamos los valores de la casilla seleccionada 		
					tablero.casillas[numcasilla] = new Casilla (numcasilla);
				
					//Actualizamos las caraceristicas del movimiento realizado por el jugador que mueva		
					tablero.jugadores[numjug - 1].movimientos ++; 
					tablero.jugadores[numjug - 1].ultimaFicha = elegido.fichaMov;
					tablero.jugadores[numjug - 1].ultimaCasilla = numcasilla;
					update(getGraphics());
					//tablero.jugadores[numjug - 1].calcularDistanciaTotalPuntoCentral(NumFicPat);
				 }
	    	}
	    	if (turno == 2)
	    	{
	    		actual.crearLista(turno,auxtablero.jugadores[turno -1].numFichaTotal,tipotabl);
	    		//elegido es un sucesor
	            elegido = minimax.decisionMiniMax(actual, auxtablero.jugadores[turno-1].nivelProfundidad, turno);
	           //elegido = minimax.decisionMiniMax(actual, tablero.jugadores[turno-1].nivelProfundidad, turno);
	            if (numMovimientos == 1)
	    		{
	    			repetido2 = elegido;
	    		}
	    		if (numMovimientos > 2)
	    		{
	    			if (repetido2.fichaMov == elegido.fichaMov && repetido2.posAnterior == elegido.posPosterior
	    					&& repetido2.posPosterior == elegido.posAnterior)
	    			{
	    				contador2++;
	    			}
	    			else
	    				contador2 = 0;
	    			repetido2 = elegido;
	    		}
	    		System.out.println("contador2: " + contador2);
	    		System.out.println("elegido " + elegido.fichaMov + "-" + elegido.posAnterior + "-" + elegido.posPosterior);
	    		System.out.println("repetido" + repetido2.fichaMov + "-" + repetido2.posPosterior + "-" + repetido2.posAnterior);
	    		
	           if (elegido.fichaMov != -1)
		        {
		            //Dibujarla pieza
		            dibujaCandidata(elegido.posPosterior%7,elegido.posPosterior/7);
		        	dibujaSeleccion(tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla%7, tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla/7);
		        
			        parpadeo();
			        parpadeo();
			        
			        if (SRCdistancia(elegido.posAnterior,elegido.posPosterior) > 1 && tipotabl == 3)
			        {
			        	elimina = funcion_elimina7x7 (elegido.posPosterior,elegido.posAnterior);
			        	elimina = elegido.fichacomida;
			        	borrarCuadro(tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla%7, tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla/7);
		
			        	fichaelimina = tablero.casillas[elimina].numficha;
			        	//borra el pato comido.
			        	borrarCuadro(tablero.jugadores[turno-2].fichas[fichaelimina].numcasilla%7, tablero.jugadores[turno-2].fichas[fichaelimina].numcasilla/7);
			        	
			        	quitacasilla = tablero.jugadores[turno-2].fichas[fichaelimina].numcasilla;
						numjug = turno;
						System.out.println("quitacasilla: " + quitacasilla + "elimina: " + elimina + "fichaelimina: " + fichaelimina);
						//Nuevo
						tablero.casillas[quitacasilla] = new Casilla(quitacasilla);
						
						//quita del pato del tablero.
						tablero.casillas[quitacasilla].quitarFichaEnSeleccionada();
						
						tablero.jugadores[0].fichas[fichaelimina].desactivarFicha();
						NumFicPat--;
						update(getGraphics());
					}
			        if (Cdistancia(elegido.posAnterior,elegido.posPosterior) > 1 && tipotabl == 5)
			        {
			        	elimina = funcion_elimina7x7 (elegido.posPosterior,elegido.posAnterior);
			        	elimina = elegido.fichacomida;
			        	borrarCuadro(tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla%7, tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla/7);
		
			        	fichaelimina = tablero.casillas[elimina].numficha;
			        	//borra el pato comido.
			        	borrarCuadro(tablero.jugadores[turno-2].fichas[fichaelimina].numcasilla%7, tablero.jugadores[turno-2].fichas[fichaelimina].numcasilla/7);
			        	
			        	quitacasilla = tablero.jugadores[turno-2].fichas[fichaelimina].numcasilla;
						numjug = turno;
						System.out.println("quitacasilla: " + quitacasilla + "elimina: " + elimina + "fichaelimina: " + fichaelimina);
						//Nuevo
						tablero.casillas[quitacasilla] = new Casilla(quitacasilla);
						
						//quita del pato del tablero.
						tablero.casillas[quitacasilla].quitarFichaEnSeleccionada();
						
						tablero.jugadores[0].fichas[fichaelimina].desactivarFicha();
						NumFicPat--;
						update(getGraphics());
					}	
			        pintarPieza(turno, elegido.posPosterior/7, elegido.posPosterior%7, true);
						
					int numcasilla = tablero.jugadores[turno-1].fichas[elegido.fichaMov].numcasilla;
					tablero.casillas[elegido.posPosterior] = new Casilla (elegido.fichaMov,turno,elegido.posPosterior);
					
					//Actualizamos los valores de la casilla candidata 		
					tablero.casillas[elegido.posPosterior].colocarFichaEnCandidata(elegido.fichaMov, numjug);
					
					//Actualizamos las caracteristicas de la casilla hacia la que se mueve la ficha 		
					//tablero.jugadores[numjug - 1].fichas[elegido.fichaMov%7].actualizarCasillaFicha(elegido.posPosterior);
					tablero.jugadores[numjug - 1].fichas[elegido.fichaMov].actualizarCasillaFicha(elegido.posPosterior);

					//Actualizamos los valores de la casilla seleccionada 		
					tablero.casillas[numcasilla] = new Casilla (numcasilla);
					tablero.casillas[numcasilla].quitarFichaEnSeleccionada();

					//Actualizamos las caraceristicas del movimiento realizado por el jugador que mueva		
					tablero.jugadores[numjug - 1].movimientos ++; 
					tablero.jugadores[numjug - 1].ultimaFicha = elegido.fichaMov;
					tablero.jugadores[numjug - 1].ultimaCasilla = numcasilla; 
					update(getGraphics());

				//	tablero.jugadores[numjug - 1].calcularDistanciaTotalPuntoCentral(1);//siempre hay un zorro
				}
	    	}
	    	
			lAviso.setText("Se ha movido la ficha "+elegido.fichaMov%7+" del jugador "+
					numjug+" a la casilla "+elegido.posPosterior);
			turno = actualizaTurno(); //Cada vez que se mueva se actualiza el turno
			lTurno.setText("Turno: Jugador "+turno);
					
			actualizaPanelTurnos();
			//update(getGraphics());
				
			if(compruebaGanador()!=0 || numMovimientos == totalMovimientos)
			{
				detenerJuego = true;
				numMovimientos = 0;
				return;
			}
			if(!detenerJuego && tablero.jugadores[turno-1].esPC)
			{
				mover_pc();
			}
		}
}



////////////////////////////////////////////////////////////////////////////////////////

@SuppressWarnings("deprecation")
public void muestraGanador()
{
	if (compruebaGanador() != 0)
    {
		tiempo.stop();
    	if(compruebaGanador() == 1)
    	{
    		lAviso.setText("FIN DE LA PARTIDA, HA GANADO "+lInfoJug1.getText().toUpperCase());
    		Opciones tem= new Opciones(this);
    		if(numjugadores == 2)
    		{
    			tem.mostrar("ganador jug1 numjugadores2");
    		}

    	}
    	else if(compruebaGanador() == 2)
    	{
    		lAviso.setText("FIN DE LA PARTIDA, HA GANADO "+lInfoJug2.getText().toUpperCase());
    		Opciones tem= new Opciones(this);
    		if (numjugadores == 2)
    		{
    			tem.mostrar("ganador jug2 numjugadores2");
    		}

    	}
    
    }
}


	public static void main(String[] args) {
		// TODO Auto-generated method stub
		new ZorraGansos("La Zorra y los Gansos");

	}

}
