import java.io.*; //Todas las librerías de entrada/salida
import java.util.ArrayList;
import java.util.List;/**/
//import java.util.List<Jugador>;
// <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
import java.util.logging.Level;
import java.util.logging.Logger;
// </editor-fold> 
public class Juego {
    final int NUM_TERRITORIOS=52;

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.18D17727-657F-8175-533C-5B36502E382B]
    // </editor-fold> 
    private int numJugadores;

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.1EC257D1-C35F-90E3-15E3-5038A4D1C07C]
    // </editor-fold> 
    private int num_turno;//¿?¿?

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.39B92F3D-5825-2A87-53BD-12ED430746A6]
    // </editor-fold> 
    private String nombrePartida;
    private boolean [] ubicados=new boolean[NUM_TERRITORIOS];
    boolean territorios_completados=false;
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.FEA1781F-3013-5F1A-CB0F-CCE79BC3E01D]
    // </editor-fold> 
    private ArrayList<Carta> Cartas;

    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.F764ADBF-14B4-F75B-3251-94A065CCDCC6]
    // </editor-fold> 
    private List<Jugador> jugadores;//nuevo
    private ArrayList<Territorio> territorios=new ArrayList();//nuevo
    private Tablero tablero;
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.FA5A5FF5-40E8-14B4-7B7C-78C5252D5227]
    // </editor-fold> 
     private Dado d1;//nuevo
     private Dado d2;//nuevo
     private Dado d3;//nuevo
     private int numrondas;//nuevo
     private int tiradas;//nuevo
     private int primeravez;//nuevo
     private Carta mCarta;//nuevo
     //private Jugador jugador;//
     private int turno=0;//nuevo
     private int numCartas;//nuevo
     private int n=0;//numero de jugadores introducidos en la tabla de jugadores
     private String nomdefensor;
     private int comprobarvecino;
     private String nombredestino;
     private int numejer;
 //***********************************************************
 //***********************************************************
//***********************************************************
//***********************************************************
    
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.2C223D41-2ABF-A4BE-E470-1099200FD26E]
    // </editor-fold> 
    public Juego (List<Jugador> listajug) {
        //quizas falta el nombre de la partida a inicializar
        jugadores=listajug;
        primeravez=0; 
        numJugadores = jugadores.size();
        d1=new Dado();
        d2=new Dado();
        for(int i=0;i<NUM_TERRITORIOS;i++) ubicados[i]=false;
        
        //Territorio t=new Territorio();
    }
    
 //***********************************************************
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.F35B06A8-BF8D-F453-7EB5-0E639478FAE1]
    // </editor-fold> 
    public String getNombrePartida () {
        return nombrePartida;
    }
 //***********************************************************
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.BEBBBC53-4B7D-ECEC-93D7-55F4DA9BFE34]
    // </editor-fold> 
    public void setNombrePartida (String val) {
        this.nombrePartida = val;
    }
 //***********************************************************
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.1B39CD7A-85A1-1E45-150E-1E987DE9432D]
    // </editor-fold> 
    public int getNumJugadores () {
        return numJugadores;
    }
 //***********************************************************
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.970E4B46-7446-6D34-F5AE-59E6057C9E97]
    // </editor-fold> 
    public void setNumJugadores (int val) {
        this.numJugadores = val;
    }
 //***********************************************************
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.54811DAC-E8B7-0529-FD7D-88139FDF5D45]
    // </editor-fold> 
    public int getNum_turno () {
        return num_turno;
    }
 //***********************************************************
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.BD98E319-1EC9-6A46-16B6-946CD4A5A0FD]
    // </editor-fold> 
    public void setNum_turno (int val) {
        this.num_turno = val;
    }
    //***********************************************************
  public int numdado1()
  {    //nuevo
        return d1.getValorCara();
    }
   //*********************************************************** 
    public int numdado2()
    { //nuevo
        return d2.getValorCara();
    }
 //***********************************************************
    public Boolean iguales()
    {//devulve si son iguales, seguramente servira rubio
                            //a la hora de atacar o defender
        return (d1.getValorCara()==d2.getValorCara());
    }
     //***********************************************************
      //***********************************************************
  /* public void abandonar()
   {//como puede abandonar cuando kiera
     if(jugadores.get(turno).estado())=0)// si esta en posicion del turno
     {
         jugadores.remove(turno);
         numJugadores=jugadores.size();         
     }
   }*/
   //***********************************************************
   /*public void perder()
   {
       if(jugadores.getNumTerritorio()<=0)
       {
           {
         jugadores.remove(turno);
         numJugadores=jugadores.size();         
          }
       }
   }*/
   //***********************************************************
   //***********************************************************
    public Jugador getjugadores(int valor)
    {
        return jugadores.get(valor);
    }
    public Jugador poseedorterritorio(int id){
        int i=0;
        int ide=-1;
        boolean encontrado=false;
        while(!encontrado && i<numJugadores){
            int j=0;
            while(j<jugadores.get(i).getNumTerritorios() && !encontrado){
                if(jugadores.get(i).getTerritorio(j)==id){
                    ide=i;
                    encontrado=true;
                }
                else j++;
            }
            
            i++;
            
        }
        /*for(i=0; i<numJugadores && encontrado==false; i++){
            for(int j=0; j<jugadores.get(i).getNumTerritorios() && encontrado==false; j++){
                if(jugadores.get(i).getTerritorio(j)==id)
                    encontrado=true;
                   
            }
        }*/
         return jugadores.get(ide);
        
                
    }
    //***********************************************************
    
    public int getrondas()
    {
        return numrondas;
    }
     //***********************************************************
    public int gettur()
    {
        return turno;
    }
    public void setturno(int val)
    {
        turno=val;
    }
    
    //***********************************************************
   public void getturno()
   {
        
        if (turno==numJugadores-1)//si es el ultimo
        {
            setturno(0);//jugador activo
            numrondas++;
        }
        else
            {
             setturno(turno+1);   
            }
                  //para que se le pase al sigueinte jugador
   }   
    //***********************************************************
   public void anadirJugador(Jugador j)
   {
       if(n<6)
       {
           //System.out.println("Vamos a añadir el jugador "+ nombreJugador + ".");
           //Jugador j=new Jugador(nombreJugador, color);
           jugadores.add(n,j);
           n++;
       }
       else
       {
          System.out.println("Numero de jugadores completo"); 
       }
           
   }
   
   public void crearMapa() throws FileNotFoundException, IOException{
       
        InputStreamReader isr = new InputStreamReader(System.in);
        FileReader flujo=new FileReader("mapa.txt");
        BufferedReader fichero=new BufferedReader(flujo);
        String sCadena=fichero.readLine();
        System.out.println(sCadena);
        //int i=0;
        while(!sCadena.contentEquals("EOF")){
           String id=fichero.readLine();
           System.out.println("ID Leído: "+id);
           String nombre=fichero.readLine();
           System.out.println("Nombre Leído: "+nombre);
           int[] vec={-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
           String vecinoSiguiente=fichero.readLine();
           int pos=0;
           int i=0;
           while(!vecinoSiguiente.contentEquals("fin")){
               vec[i]=Integer.parseInt(vecinoSiguiente);
               vec[i]--;
               i++;
               vecinoSiguiente=fichero.readLine();
           }
           for(int j=0;j<10;j++) System.out.println("Vecino ["+j+"]="+vec[j]);
           int ident=Integer.parseInt(id);
           ident--;
           Territorio t1=new Territorio(nombre,ident,vec);
           territorios.add(t1);
           pos++;
           sCadena=fichero.readLine();
           System.out.println("Siguiente territorio, LEO:"+sCadena);
                  
        }
        
    }
   
   
   public void jugar() throws IOException{
       
      //  Tablero t=new Tablero();
       crearMapa();
       InputStreamReader isr = new InputStreamReader(System.in);
        //Para crear un flujo de entrada
        BufferedReader br = new BufferedReader(isr);
        do{
            System.out.println("Bienvenido a Urban Risk\n");
            System.out.println("Por favor, introduzca el número de jugadores: ");
            try {
                String numero = br.readLine();
                numJugadores = Integer.parseInt(numero);
            } catch (IOException ex) {
                Logger.getLogger(Juego.class.getName()).log(Level.SEVERE, null, ex);
            }
            if (numJugadores < 2){
                System.out.println("\nDeben jugar como mínimo dos jugadores");
            }
            if (numJugadores > 6){
                System.out.println("\nEl máximo es de seis jugadores");
            }
        }while(numJugadores<2 || numJugadores>6);
      
        int[] orden = new int[getNumJugadores()]; //Una tabla que guarda el resultado de las tiradas para el comienzo
        boolean[] cogidas = new boolean[6];//true si el ejercito está cogido.
        
        for (int i=0; i<getNumJugadores(); i++){
            int opEjercito= 0;
            String nombre=new String();
            boolean bienEscogido=false;
            do{
                System.out.println("Por favor, introduzca el nombre del jugador "+ (i+1) +": ");
                try {
                    nombre = br.readLine();
                } catch (IOException ex) {
                    Logger.getLogger(Juego.class.getName()).log(Level.SEVERE, null, ex);
                }
                System.out.println("\n\nEJERCITOS DISPONIBLES:");
                System.out.println("\n1.-Pijos");
                System.out.println("2.-Canis");
                System.out.println("3.-Frikis");
                System.out.println("4.-Heviatas");
                System.out.println("5.-Raperos");
                System.out.println("6.-Jipis Guarros");
                System.out.println("¿Qué ejército capitaneará "+ nombre +"? -->  ");
                try {
                    String opc = br.readLine();
                    opEjercito = Integer.parseInt(opc);
                } catch (IOException ex) {
                    Logger.getLogger(Juego.class.getName()).log(Level.SEVERE, null, ex);
                }
                if (opEjercito>6 || opEjercito<1){
                    System.out.println("\nOpcion Inválida");
                }
                else{
                    if (cogidas[opEjercito-1]==true){
                        System.out.println("\nEse ejército ya ha sido seleccionado por otro jugador");
                    }
                    else{
                        cogidas[opEjercito-1]=true;
                        bienEscogido=true;
                    }
                }
            }while(bienEscogido==false);
            opEjercito--;
            Jugador j= new Jugador(nombre,(char)(opEjercito),n);
            anadirJugador(j);
        }
        System.out.println("\n");
        System.out.println("\n");
        System.out.println("\n");
        System.out.println("\n");
        int opMenuPrincipal=0;
        do{
            
            System.out.println("----MENU PRINCIPAL----");
            System.out.println(" ");
            System.out.println("\n1.- Comenzar partida");
            System.out.println("2.- Finalizar partida");
            System.out.println("\n\nIntroduzca una opción: ");
            String opcion=br.readLine();
            opMenuPrincipal=Integer.parseInt(opcion);
            
            switch(opMenuPrincipal){
                case 1: 
                    reparteTerritorios();
                    boolean iguales=false; //Por si se empatan las tiradas
                    System.out.println("\nSe va a proceder a la tirada que determinará el orden...");
                    do{
                        for (int i=0;i<numJugadores;i++){
                            d1.tirarDado();
                            orden[i]=d1.getValorCara();
                            System.out.println("Tirada del jugador "+ getjugadores(i).getNombre() +": "+ orden[i] );
                        }
                        int mayor=orden[0];
                        int primero=0;
                        iguales=false;
                        
                        for (int i=0;i<numJugadores;i++){
                            if (orden[i]>mayor) {
                                mayor = orden[i]; //guardo el numero y la posicion de la tirada mayor
                                primero=i; 
                            }
                        }
                        
                        for (int i=0;i<numJugadores && iguales!=true;i++){
                            if (orden[i]==mayor && i!=primero) iguales=true;// busco a ver si hay alguna tirada empatada
                         }
                        if (iguales==true) System.out.println("Ha habido un empate en la tirada por el orden de la partida");
                        else setturno(primero); //Le doy el turno al que le toca.
                    } while(iguales==true);
                    
                    fasePrevia();
                    //Fase previa llama a ubicar dentro de un bucle y pasa los turnos
                    
            
                    System.out.println("\n");
                    System.out.println("\n");
                    
                    System.out.println("    COMIENZA LA PARTIDA!!!\n");
                    char opMenuJugador='0';
                    
                    do{
                        System.out.println("MENU DEL JUGADOR "+getjugadores(gettur()).getNombre());
                        System.out.println("\n1.- Ubicar Tropas de Refuerzo");
                        System.out.println("2.- Ver Estado");
                        System.out.println("3.- Canjear Cartas");
                        System.out.println("4.- Retirarse");
                        System.out.println("4.- Ver Manual");
                        System.out.println("5.- Finalizar Turno");
                        System.out.println("6 - Atacar");
                        System.out.println("9.- Salir al Menu Principal");
                        
                        System.out.println("Escoja una opción: ");
                        opMenuJugador=(char)System.in.read();                      
                        int j=(int)System.in.read();        
                        switch(opMenuJugador){
                            case '1':
                            case '2':
                            case '3':
                            case '4': System.out.println("\nOpción no implementada");
                                      break;
                            case '5': getturno();                            
                                      break;
                            case '6': atacar();
                                      break;
                            case '9': break;
                            default: System.out.println("\nOpción inválida\n");
                                     break;
                         
                        }                  
                    }while(opMenuJugador!='9');
                                 
                    break;
                case 2: 
                    System.out.println("Partida finalizada correctamente");
                    break;
                
            }
        
        }while(opMenuPrincipal!=2);
        
   }
  //*********************************************************** 
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.B9E91B01-8D3D-504B-549A-6B3E67885054]
    // </editor-fold> 
    public void cargarPartida (String nombreP) {
    }
 //***********************************************************
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.2537877A-00AE-88ED-EB40-81143ADBF7F0]
    // </editor-fold> 
    public void guardarPartida (String nombreP) {
    }
 //***********************************************************
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.B2AED7C3-2BAC-ADAD-23D3-7C1845374ADD]
    // </editor-fold> 
    public void atacar (/*int origen, int destino*/)
    { 
        InputStreamReader isr = new InputStreamReader(System.in);
        //Para crear un flujo de entrada
        BufferedReader br = new BufferedReader(isr);
        boolean encontrado=false;
        int valor1, valor2, valor1a, valor2a, valor3a, valor1d, valor2d, valor3d;
        int maximo1, maximo2, minimo1, minimo2;
        int idvecino = 0, nvecinos;
        int torigen=-1; 
        int tdestino=-1;
        
        Jugador jug;
        System.out.println("Listado de los territorios origen: ");
            
        for(int i=0; i<getjugadores(gettur()).getNumTerritorios(); i++){
            String nombreorigen=territorios.get(getjugadores(gettur()).getTerritorio(i)).getNomTerritorio();
            int no=getjugadores(gettur()).getTerritorio(i);
            System.out.println("Identificador"+no+"    Nombre: "+nombreorigen);
              
        }
         System.out.println("Insertar el numero del territorio origen: ");
         try{
            String numero = br.readLine();
            torigen = Integer.parseInt(numero);
         } catch (IOException ex) {
                    Logger.getLogger(Juego.class.getName()).log(Level.SEVERE, null, ex);
         }
        /* System.out.println("Vecinos REALES del territorio "+torigen);
         territorios.get(torigen).muestraVecinos();
         System.out.println("Numero de vecinos REALES del territorio"+torigen);
         System.out.println(territorios.get(torigen).getNumVecinos());*/
         if(getjugadores(gettur()).ExisteTerritorio(torigen)==true)
         {
             //int t=getjugadores(gettur()).getTerritorio(torigen);
             nvecinos=territorios.get(torigen).getNumVecinos();
             //System.out.println(nvecinos);
             System.out.println("Listado de los territorios vecinos: ");
               
             for(int i=0; i<nvecinos; i++){
               idvecino=territorios.get(torigen).IdentVecino(i);
               //int idv=territorios.get(getjugadores(gettur()).getTerritorio(torigen)).IdentVecino(idvecino);
               //System.out.println(idvecino);
               nombredestino=territorios.get(idvecino).getNomTerritorio();
               System.out.println("Identificador"+idvecino+"    Nombre: "+nombredestino);
               
                          
             }
             System.out.println("Insertar el numero del territorio vecino: ");
             try{
                String numero2 = br.readLine();
                tdestino = Integer.parseInt(numero2);
              } catch (IOException ex){ 
                    Logger.getLogger(Juego.class.getName()).log(Level.SEVERE, null, ex);
              }
             int j=0;
             while(j<nvecinos && encontrado==false){
                 comprobarvecino=territorios.get(torigen).IdentVecino(j);
                 if(comprobarvecino==tdestino)
                     encontrado=true;
                 else 
                     j++;
             }
            
             if(encontrado==true){

                      System.out.println("Comienzan los ataques entre barrios!!!!!!!");
                      int ntropas=territorios.get(torigen).getNumTropas();
                      if(ntropas>=2)
                      {
                                 System.out.println("El numero de tropas que posee el jugador atacante son: "+ntropas);
                                 System.out.println("Jugador atacante elija numero de ejercitos con los que atacar: ");
                                 try{
                                    String numero3 = br.readLine();
                                    numejer = Integer.parseInt(numero3);
                                 }catch (IOException ex) {
                                    Logger.getLogger(Juego.class.getName()).log(Level.SEVERE, null, ex);
                                 }
                                 System.out.println("____________Tiradas de dados_______________");
                                 if(numejer==1)  
                                 {
                                  
                                      System.out.println("Tirada del jugador atacante"+getjugadores(gettur()).getNombre()+": ");
                                      d1.tirarDado();
                                      valor1=d1.getValorCara();
                                      System.out.println("Resultado del jugador atacante "+getjugadores(gettur()).getNombre()+": "+valor1 );
                                      jug=poseedorterritorio(comprobarvecino);
                                      /*System.out.println("Datos del jugador "+comprobarvecino);
                                      System.out.println("Identificador:"+jug.getIdentificador());
                                      System.out.println("Nombre: "+jug.getNombre());
                                      System.out.println("Nombre del jugador atacante: "+jugadores.get(gettur()).getNombre());
                                      System.out.println(jugadores.get(gettur()).getIdentificador());*/
                                      if(jug.getIdentificador()!=jugadores.get(gettur()).getIdentificador()){//devulve el jugador al que pertenece el territorio comprobarvecino
                                         nomdefensor=jug.getNombre();
                                      System.out.println("Tirada del jugador defensor "+nomdefensor+": ");
                                      d1.tirarDado();
                                      valor2=d1.getValorCara();
                                      System.out.println("Resultado del jugador defensor "+nomdefensor+": "+valor2);
                                             if(valor1>valor2)
                                             {
                                                 System.out.println("El jugador atacante: "+getjugadores(gettur()).getNombre()+". Has ganado!!");
                                                 jug.setNumTropas(jug.getNumTropas()-numejer); //decrementamos el numero de tropas del jugador defensor
                                             }
                                             else{
                                                 System.out.println("El jugador defensor: "+nomdefensor+". Has ganado!!");
                                                 getjugadores(gettur()).setNumTropas(ntropas-numejer); //decrementamos el numero de tropas del jugador atacante

                                             }

                                }
                                 }
                                //********************************************++ 
                                 else if(numejer==2)  
                                 { 
                                      System.out.println("Tirada del jugador atacante"+getjugadores(gettur()).getNombre()+": ");
                                      d1.tirarDado();
                                      valor1a=d1.getValorCara();
                                      d1.tirarDado();                                      
                                      valor2a=d1.getValorCara();
                                      if(valor1a>=valor2a){
                                          maximo1=valor1a;
                                          minimo1=valor2a;
                                      }
                                      else{
                                          maximo1=valor2a;
                                          minimo1=valor1a;
                                      }
                                      System.out.println("Resultado del jugador atacante "+getjugadores(gettur()).getNombre()+": "+valor1a+ ", "+ valor2a);
                                      jug=poseedorterritorio(comprobarvecino);
                                      if(jug.getIdentificador()!=jugadores.get(gettur()).getIdentificador()){//devulve el jugador al que pertenece el territorio comprobarvecino
                                         nomdefensor=jug.getNombre();
                                      System.out.println("Tirada del jugador defensor "+nomdefensor+": ");
                                      d1.tirarDado();
                                      valor1d=d1.getValorCara();
                                      d1.tirarDado();
                                      valor2d=d1.getValorCara();
                                      
                                      
                                      if(valor1d>=valor2d){
                                          maximo2=valor1d;
                                          minimo2=valor2d;
                                      }
                                      else{
                                          maximo2=valor2d;
                                          minimo2=valor1d;
                                      }

                                      System.out.println("Resultado del jugador defensor "+nomdefensor+": "+ valor1d+", "+valor2d);
                                             //comprabacion de maximos
                                             int nt=0;
                                             int nt2=0;
                                             if(maximo1>maximo2 && minimo1>minimo2)
                                             {
                                                 nt=(jug.getNumTropas()-numejer);
                                                 System.out.println("El jugador atacante: "+getjugadores(gettur()).getNombre()+"gana la partida");                                                 
                                                 jug.setNumTropas(nt); //decrementamos el numero de tropas del jugador defensor
                                             }
                                             else if((maximo1>maximo2 && minimo1<=minimo2) || (maximo1<=maximo2 && minimo1>minimo2)){
                                                 nt= getjugadores(gettur()).getNumTropas()-1;
                                                 nt2=jug.getNumTropas()-1;
                                                 System.out.println("Se ha producido un empate!!");
                                                 getjugadores(gettur()).setNumTropas(nt); //decrementamos el numero de tropas del jugador atacante
                                                 jug.setNumTropas(nt2);
                                                 

                                             }
                                             else{
                                                nt=ntropas-numejer; 
                                                System.out.println("El jugador defensor: "+jug.getNombre()+"gana la partida");
                                                getjugadores(gettur()).setNumTropas(nt); 
                                             
                                             }
                                          
                                             }
                                      
                                }//fin de ejercito numejer=2
                                //***********************************************************+ 
                                 else if(numejer==3)  
                                 {    
                                      int [] tiradasAtaque=new int[3];
                                      System.out.println("Tirada del jugador atacante "+getjugadores(gettur()).getNombre()+": ");
                                      d1.tirarDado();
                                      tiradasAtaque[0]=d1.getValorCara();
                                      d1.tirarDado();
                                      tiradasAtaque[1]=d1.getValorCara();
                                      d1.tirarDado();
                                      tiradasAtaque[2]=d1.getValorCara();
                                      int aux=0;
                                      for(int i=0;i<tiradasAtaque.length;i++){
                                          for(int k=0;k<tiradasAtaque.length;k++){
                                              if(tiradasAtaque[i]>tiradasAtaque[k]){
                                                  aux=tiradasAtaque[i];
                                                  tiradasAtaque[i]=tiradasAtaque[k];
                                                  tiradasAtaque[k]=aux;
                                              }
                                          }
                                      }
                                      
                                      /*if(valor1a>=valor2a && valor1a>=valor3a || valor1a>valor2a && valor2a>=valor3a)
                                          maximo1a=valor1a;
                                          maximo2a=valor2a;
                                      else if(valor1a>=valor2a && valor1a>=valor3a || valor1a>valor2a && valor2a>=valor3a){
                                          maximo1a=valor1a;
                                          maximo2a=valor2a;
                                      }*/
                                      //else
                                          //maximo1=valor3a;
                                      //alert(tiradasAtaque.sort());
                                      valor1a=tiradasAtaque[0];
                                      valor2a=tiradasAtaque[1];
                                      valor3a=tiradasAtaque[2];
                                      System.out.println("Resultado del jugador atacante "+getjugadores(gettur()).getNombre()+": "+ valor1a+", "+valor2a+", "+valor3a);
                                      jug=poseedorterritorio(comprobarvecino);
                                      if(jug.getIdentificador()!=jugadores.get(gettur()).getIdentificador()){//devulve el jugador al que pertenece el territorio comprobarvecino
                                         nomdefensor=jug.getNombre();
                                      System.out.println("Tirada del jugador defensor "+nomdefensor+": ");
                                      int[] tiradasDefensa=new int[2];
                                      d1.tirarDado();
                                      d2.tirarDado();
                                      tiradasDefensa[0]=d1.getValorCara();
                                     tiradasDefensa[1]=d2.getValorCara();
                                      /*for(int i=0;i<tiradasDefensa.length;i++){
                                          for(int k=tiradasDefensa.length-1;k==0;k--){
                                              if(tiradasDefensa[i]<tiradasDefensa[k]){
                                                  aux=tiradasDefensa[i];
                                                  tiradasDefensa[i]=tiradasDefensa[k];
                                                  tiradasDefensa[k]=aux;
                                              }
                                          }
                                      }*/
                                      if(tiradasDefensa[0]<tiradasDefensa[1]){
                                          aux=tiradasDefensa[0];
                                                  tiradasDefensa[0]=tiradasDefensa[1];
                                                  tiradasDefensa[1]=aux;
                                      }
                                      /*if(valor1d>=valor2d)
                                          maximo2=valor1d;
                                      else
                                          maximo2=valor2d;
                                      */
                                     valor1d=tiradasDefensa[0];
                                     valor2d=tiradasDefensa[1];
                                      System.out.println("Resultado del jugador defensor "+nomdefensor+": "+ valor1d+", "+valor2d);
                                             //comprabacion de maximos
                                             if(valor1a>valor1d && valor2a>valor2d)
                                             {
                                                 System.out.println("El jugador atacante: "+getjugadores(gettur()).getNombre()+". Has ganado!!");
                                                 jug.setNumTropas(jug.getNumTropas()-numejer); //decrementamos el numero de tropas del jugador defensor
                                             }
                                             else if(valor1a<=valor1d && valor2a<=valor2d){
                                                 System.out.println("El jugador defensor: "+nomdefensor+". Has ganado!!");
                                                 getjugadores(gettur()).setNumTropas(ntropas-numejer); //decrementamos el numero de tropas del jugador atacante
                                             }
                                             else{
                                                 //System.out.println("El jugador defensor: "+nomdefensor+". Has ganado!!");
                                                 System.out.println("Se ha porducido un empate");
                                                 getjugadores(gettur()).setNumTropas(ntropas-numejer); //decrementamos el numero de tropas del jugador atacante

                                             }
                                      }
                                }//fin de ejercito numejer=2 
                        }
              }//fin encontrado
                       
         }
         else
              System.out.println("El identificador del territorio origen es incorrecto!!");
             
          
   }      
 //***********************************************************
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.0BA91DB7-C764-693A-2FA4-C68885F8B88A]
    // </editor-fold> er
    public void ubicar() {
        
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        int indica_territorio=0;
        boolean correcto=false;
        //boolean [] ubicados=new boolean[NUM_TERRITORIOS];
        
        //boolean territorios_completados=false;
        do{
            System.out.println("----FASE PREVIA----");
            System.out.println("Turno del jugador " + getjugadores(gettur()).getNombre());
            System.out.println("¿Dónde desea ubicar sus tropas?");
            for (int i=0;i<getjugadores(gettur()).getNumTerritorios();i++){
                       Territorio t=territorios.get(getjugadores(gettur()).getTerritorio(i));
                       System.out.println("Territorio " +t.getIdentificador() + " - "+t.getNomTerritorio());
                      
            }
            
           System.out.println("Opción:");
            
            try {
                String numero = br.readLine();
                indica_territorio = Integer.parseInt(numero);
                } catch (IOException ex) {
                    Logger.getLogger(Juego.class.getName()).log(Level.SEVERE, null, ex);
                }
         
            //correcto=true;
           if(indica_territorio>-1 && indica_territorio<51){
            if (getjugadores(gettur()).ExisteTerritorio(indica_territorio)){
                
                int nuevoNum=territorios.get(indica_territorio).getNumTropas();
                territorios.get(indica_territorio).setNumTropas(nuevoNum+1);
                int nuevaTrop=getjugadores(gettur()).getTropasPendUbicar();
                getjugadores(gettur()).setTropasPendUbicar(nuevaTrop-1);
                System.out.println("El territorio "+territorios.get(indica_territorio).getNomTerritorio()+" ahora tiene "+territorios.get(indica_territorio).getNumTropas());
                //correcto=true;
                
            }
            else System.out.println("Ese territorio no te pertenece PÁJARO!!");
                 //correcto=false;
            
            /*else if (ubicados[indica_territorio-1]==true){
                System.out.println("Antes de repetir ubicación, debes poner tropas en todos tus territorios!!!");
                correcto=false;
            }*/
           }
           else System.out.println("Indice de territorio invalido");
         }while(!getjugadores(gettur()).ExisteTerritorio(indica_territorio) || indica_territorio<0 || indica_territorio>51);
        
    }  
 //***********************************************************
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.29A7E251-A344-DD27-8740-92EE9A70B7C9]
    // </editor-fold> 
    public void transferir () {
    }
 //***********************************************************
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.0AA044F4-3F72-02E4-1A8B-6F2292A799D0]
    // </editor-fold> 
    public void fasePrevia () {
        
        while(getjugadores(gettur()).getTropasPendUbicar()>0){       
            ubicar();
            getturno();
              
            
        }
    }
    
    public void reparteTerritorios(){
        int jug=0;
        for(int i=0;i<52;i++){
            if(jug==numJugadores)jug=0;
            getjugadores(jug).setTerritorio(i);
            jug++;
        }
        
    }
 //***********************************************************
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.C78A8043-2E61-47FB-746B-00F850B6B6B3]
    // </editor-fold> 
    public void abandonar () {
    }
 //***********************************************************
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.BEF48F1D-B5F3-CB95-E352-0ACD5996E115]
    // </editor-fold> 
    public void anadirJugador () {
    }
 //***********************************************************
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.C3D612F1-66EB-0EFD-A9CC-FA8FC0CEAEB8]
    // </editor-fold> 
    public void finalizarTurno () {
    }
 //***********************************************************
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.351A78D6-29E6-0C53-4ED6-84034E0FA9B2]
    // </editor-fold> 
    public ArrayList<Carta> getCartas () {
        return Cartas;
    }
 //***********************************************************
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.E5C01141-3346-D9B9-D5DE-24D050FF98C6]
    // </editor-fold> 
    public void setCartas (ArrayList<Carta> val) {
        this.Cartas = val;
    }
 //***********************************************************
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.7CC9DC6D-0096-6527-4048-2F77C92EA163]
    // </editor-fold> 
    public Carta getCarta () {
        return mCarta;
    }
 //***********************************************************
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,regenBody=yes,id=DCE.839EB2CA-C60E-0730-83BE-8C49FC833777]
    // </editor-fold> 
    public void setCarta (Carta val) {
        this.mCarta = val;
    }

      //***********************************************************
  public int numCartas()
    {
        return numCartas;
    }
     //***********************************************************
}

