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.Observable;
import java.util.Random;
import java.util.logging.Level;
import java.util.logging.Logger;
// </editor-fold> 
public class Juego extends Observable{
    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=new ArrayList();

    // <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;
     private Dado d4;
     private Dado d5;//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) throws FileNotFoundException, IOException {
        //quizas falta el nombre de la partida a inicializar
        crearMapa();
        crearcartas();
        tablero=new Tablero(Territorios);
        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(Territorio t){
        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)==t){
                    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 getturnoFasePrevia()
   {
        
        if (turno==numJugadores-1)//si es el ultimo
        {
            setturno(0);//jugador activo
            numrondas++;
        }
        else
            {
             setturno(turno+1);   
            }
        //calc_rearmamiento(jugadores.get(gettur()).getNumTerritorios());
                  //para que se le pase al sigueinte jugador
        setChanged();
        notifyObservers();
   }  
   public void getturno()
   {
       boolean correcto=false;
       do{
        if (getjugadores(gettur()).getTropasPendUbicar()>0){
            System.out.println("Tienes tropas pendientes de ubicar!!");
            rearmamiento();
        }
        else{
            correcto=true;
        if (turno==numJugadores-1)//si es el ultimo
        {
            setturno(0);//jugador activo
            numrondas++;
        }
        else
            {
             setturno(turno+1);   
            }
        //calc_rearmamiento(jugadores.get(gettur()).getNumTerritorios());
        }
       }while(!correcto);//para que se le pase al sigueinte jugador
       setChanged();
       notifyObservers();
   }   
    //***********************************************************
   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);
           System.out.println("Jugador añadido");
           System.out.println("Datos del jugador añadido:");
           System.out.println("Nombre:"+jugadores.get(n).getNombre());
           System.out.println("Ejercito:"+jugadores.get(n).getColor());
           n++;
       }
       else
       {
          System.out.println("Numero de jugadores completo"); 
       }
           
   }
   
   public void crearZonas(){
       
   }
   
   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();
           String nombre=fichero.readLine();
           String leeZona=fichero.readLine();
           int zona=Integer.parseInt(leeZona);
           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();
           }
           int ident=Integer.parseInt(id);
           ident--;
           
           Territorio t1=new Territorio(nombre,ident,vec,zona);
           Territorios.add(t1);
           pos++;
           sCadena=fichero.readLine();
                          
        }
        
    }
   
   public void asignarTurnos(){
       boolean iguales=false; //Por si se empatan las tiradas
                    System.out.println("\nSe va a proceder a la tirada que determinará el orden...");
                    int orden[]=new int[getNumJugadores()];
                    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);
                    repartoCartas();
                    setChanged();
                    notifyObservers();
       
   }
   
   
   public void jugar() throws IOException{
       
      //  Tablero t=new Tablero();
       //crearMapa();
       //tablero.mostrarTodo();
       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("7.- Transferir tropas");
                        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': //rearmamiento();
                                      break;
                            case '2':
                            case '3':
                            case '4': System.out.println("\nOpción no implementada");
                                      break;
                            case '5': getturno();                            
                                      break;
                            case '6': atacar();
                                      break;
                            case '7': transferencia();
                                      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) {
    }
 //***********************************************************
    public void muestraTerritoriosJugador(int numJug){//Muestra los territorios del jugador que le pasas
        for(int i=0; i<getjugadores(numJug).getNumTerritorios(); i++){
            String nombreorigen=Territorios.get(getjugadores(numJug).getTerritorio(i).getIdentificador()).getNomTerritorio();
            int no=getjugadores(gettur()).getTerritorio(i).getIdentificador();
            System.out.println(no+" - "+nombreorigen);
              
        }
    }
    
    public void muestraTerritoriosVecinos(int idTerritorio){//muestra los vecinos del territorio cuyo id se pasa
        int nvecinos=Territorios.get(idTerritorio).getNumVecinos();
        for(int i=0;i<nvecinos;i++){
           int idVecino=Territorios.get(idTerritorio).IdentVecino(i);
           Territorio t=Territorios.get(idVecino);
           System.out.println(t.getIdentificador()+" - "+t.getNomTerritorio());
        }
    }
    
    public int batalla(int tOrigen,int tDestino, int tropasAtaque, int tropasDestino){
        int [] tiradasAtaque=new int[3];
        int [] tiradasDefensa=new int[2];
        int retorno=0;
        boolean victoria=false;
        switch(tropasAtaque){
            case 1: d1.tirarDado();
                    tiradasAtaque[0]=d1.getValorCara();
                    d2.tirarDado();
                    tiradasDefensa[0]=d2.getValorCara();
                    System.out.println("Tirada de Ataque: "+tiradasAtaque[0]);
                    System.out.println("Tirada de Defensa: "+tiradasDefensa[0]);
                    if(tiradasAtaque[0]>tiradasDefensa[0]){
                        int nuevoNumTropas=Territorios.get(tDestino).getNumTropas()-1;
                        Territorios.get(tDestino).setNumTropas(nuevoNumTropas);
                        System.out.println("¡¡BOOOM!! El territorio "+Territorios.get(tDestino).getIdentificador()+" - "+Territorios.get(tDestino).getNomTerritorio()+" ha perdido una tropa");
                        if (Territorios.get(tDestino).getNumTropas()==0){ 
                            System.out.println("¡¡CRASH!! El territorio "+Territorios.get(tDestino).getIdentificador()+" - "+Territorios.get(tDestino).getNomTerritorio()+" ha sido conquistado por "+getjugadores(gettur()).getNombre() );
                            if(!(tieneZonaCompleta(poseedorterritorio(Territorios.get(tDestino)).getIdentificador(), Territorios.get(tDestino).getZona()))){
                                int z=Territorios.get(tDestino).getZona();
                                tablero.getZona(z).setJugadorPoseedor(-1);
                                
                            }
                            invadir(tOrigen,tDestino);
                            System.out.println("Vamos a comprobar si el jugador ha conquistado la Zona");
                            System.out.println("ID: "+ tablero.getZona(Territorios.get(tDestino).getZona()).getJugadorPoseedor());
                            System.out.println("Zona: "+ Territorios.get(tDestino).getZona());
                            if(tieneZonaCompleta(jugadores.get(gettur()).getIdentificador(), Territorios.get(tDestino).getZona())){
                                int z=Territorios.get(tDestino).getZona();
                                tablero.getZona(z).setJugadorPoseedor(jugadores.get(gettur()).getIdentificador());
                                System.out.println("El jugador "+tablero.getZona(z).getJugadorPoseedor()+" ahora posee la zona "+ tablero.getZona(z).getNomZona());
                            }
                            retorno=1;
                        }
                       
                    }
                    else {
                        int nuevoNumTropas=Territorios.get(tOrigen).getNumTropas()-1;
                        Territorios.get(tOrigen).setNumTropas(nuevoNumTropas);
                        System.out.println("El territorio "+Territorios.get(tOrigen).getIdentificador()+" - "+Territorios.get(tOrigen).getNomTerritorio()+" ha perdido una tropa");
                        retorno=2;
                    }
                    break;
            case 2: switch(tropasDestino){
                                   case 2:d1.tirarDado();
                                          d2.tirarDado();
                                          //d3.tirarDado();
                                          tiradasAtaque[0]=d1.getValorCara();
                                          tiradasAtaque[1]=d2.getValorCara();
                                          //tiradasAtaque[2]=d3.getValorCara();
                                          d1.tirarDado();
                                          d2.tirarDado();
                                          tiradasDefensa[0]=d1.getValorCara();
                                          tiradasDefensa[1]=d2.getValorCara();
                                          if(tiradasAtaque[0]<tiradasAtaque[1]){
                                              int aux=tiradasAtaque[0];
                                              tiradasAtaque[0]=tiradasAtaque[1];
                                              tiradasAtaque[1]=aux;
                                          }
                                          if(tiradasDefensa[0]<tiradasDefensa[1]){
                                              int aux=tiradasDefensa[0];
                                              tiradasDefensa[0]=tiradasDefensa[1];
                                              tiradasDefensa[1]=aux;
                                          }
                                          System.out.println("Tirada de Ataque: "+tiradasAtaque[0]+", "+tiradasAtaque[1]);
                                          System.out.println("Tirada de Defensa: "+tiradasDefensa[0]+", "+tiradasDefensa[1]);
                                          if(tiradasAtaque[0]>tiradasDefensa[0]){
                                             int nuevoNumTropas=Territorios.get(tDestino).getNumTropas()-1;
                                             Territorios.get(tDestino).setNumTropas(nuevoNumTropas);
                                             System.out.println("¡¡BOOOM!! El territorio "+Territorios.get(tDestino).getIdentificador()+" - "+Territorios.get(tDestino).getNomTerritorio()+" ha perdido una tropa");
                                             if (Territorios.get(tDestino).getNumTropas()==0){ 
                                                 victoria=true;
                                                //System.out.println("El territorio "+territorios.get(tDestino).getIdentificador()+" - "+territorios.get(tDestino).getNomTerritorio()+" ha sido conquistado por "+getjugadores(gettur()) );
                                               if(!(tieneZonaCompleta(poseedorterritorio(Territorios.get(tDestino)).getIdentificador(), Territorios.get(tDestino).getZona()))){
                                                    int z=Territorios.get(tDestino).getZona();
                                                    tablero.getZona(z).setJugadorPoseedor(-1);
                                
                                               }
                                               invadir(tOrigen,tDestino);
                                               System.out.println("Vamos a comprobar si el jugador ha conquistado la Zona");
                                               System.out.println("ID: "+ tablero.getZona(Territorios.get(tDestino).getZona()).getJugadorPoseedor());
                                               System.out.println("Zona: "+ Territorios.get(tDestino).getZona());
                                               if(tieneZonaCompleta(jugadores.get(gettur()).getIdentificador(), Territorios.get(tDestino).getZona())){
                                                  int z=Territorios.get(tDestino).getZona();
                                                  tablero.getZona(z).setJugadorPoseedor(jugadores.get(gettur()).getIdentificador());
                                                  System.out.println("El jugador "+tablero.getZona(z).getJugadorPoseedor()+" ahora posee la zona "+ tablero.getZona(z).getNomZona());
                                               }
                                               retorno=1;
                                             }
                                          }
                                          else {
                                               int nuevoNumTropas=Territorios.get(tOrigen).getNumTropas()-1;
                                               Territorios.get(tOrigen).setNumTropas(nuevoNumTropas);
                                               System.out.println("¡¡CRASH!! El territorio "+Territorios.get(tOrigen).getIdentificador()+" - "+Territorios.get(tOrigen).getNomTerritorio()+" ha perdido una tropa");
                                               retorno=2;
                                          }
                                          if(!victoria){
                                               if (tiradasAtaque[1]>tiradasDefensa[1]){
                                                    int nuevoNumTropas=Territorios.get(tDestino).getNumTropas()-1;
                                                    Territorios.get(tDestino).setNumTropas(nuevoNumTropas);
                                                    System.out.println("¡¡BABOOM!! El territorio "+Territorios.get(tDestino).getIdentificador()+" - "+Territorios.get(tDestino).getNomTerritorio()+" ha perdido una tropa");
                                                    if (Territorios.get(tDestino).getNumTropas()==0){ 
                                                        System.out.println("El territorio "+Territorios.get(tDestino).getIdentificador()+" - "+Territorios.get(tDestino).getNomTerritorio()+" ha sido conquistado por "+getjugadores(gettur()).getNombre() );
                                                         if(!(tieneZonaCompleta(poseedorterritorio(Territorios.get(tDestino)).getIdentificador(), Territorios.get(tDestino).getZona()))){
                                                    int z=Territorios.get(tDestino).getZona();
                                                    tablero.getZona(z).setJugadorPoseedor(-1);
                                                    retorno=1;
                                
                                               }
                                               invadir(tOrigen,tDestino);
                                               System.out.println("Vamos a comprobar si el jugador ha conquistado la Zona");
                                               System.out.println("ID: "+ tablero.getZona(Territorios.get(tDestino).getZona()).getJugadorPoseedor());
                                               System.out.println("Zona: "+ Territorios.get(tDestino).getZona());
                                               if(tieneZonaCompleta(jugadores.get(gettur()).getIdentificador(), Territorios.get(tDestino).getZona())){
                                                  int z=Territorios.get(tDestino).getZona();
                                                  tablero.getZona(z).setJugadorPoseedor(jugadores.get(gettur()).getIdentificador());
                                                  System.out.println("El jugador "+tablero.getZona(z).getJugadorPoseedor()+" ahora posee la zona "+ tablero.getZona(z).getNomZona());
                                               }
                                                    }
                                               }
                                               else {
                                                    int nuevoNumTropas=Territorios.get(tOrigen).getNumTropas()-1;
                                                    Territorios.get(tOrigen).setNumTropas(nuevoNumTropas);
                                                    System.out.println("¡¡CATACROKET!! El territorio "+Territorios.get(tOrigen).getIdentificador()+" - "+Territorios.get(tOrigen).getNomTerritorio()+" ha perdido una tropa");
                                                    retorno=2;
                                               } 
                                           }
                                           else { if(!(tieneZonaCompleta(poseedorterritorio(Territorios.get(tDestino)).getIdentificador(), Territorios.get(tDestino).getZona()))){
                                                    int z=Territorios.get(tDestino).getZona();
                                                    tablero.getZona(z).setJugadorPoseedor(-1);
                                
                                               }
                                               invadir(tOrigen,tDestino);
                                               System.out.println("Vamos a comprobar si el jugador ha conquistado la Zona");
                                               System.out.println("ID: "+ tablero.getZona(Territorios.get(tDestino).getZona()).getJugadorPoseedor());
                                               System.out.println("Zona: "+ Territorios.get(tDestino).getZona());
                                               if(tieneZonaCompleta(jugadores.get(gettur()).getIdentificador(), Territorios.get(tDestino).getZona())){
                                                  int z=Territorios.get(tDestino).getZona();
                                                  tablero.getZona(z).setJugadorPoseedor(jugadores.get(gettur()).getIdentificador());
                                                  System.out.println("El jugador "+tablero.getZona(z).getJugadorPoseedor()+" ahora posee la zona "+ tablero.getZona(z).getNomZona());
                                               }
                                           }
                                           break;
                                   case 1: d1.tirarDado();
                                           d2.tirarDado();
                                           tiradasAtaque[0]=d1.getValorCara();
                                           tiradasAtaque[1]=d2.getValorCara();
                                           d1.tirarDado();
                                           tiradasDefensa[0]=d1.getValorCara();
                                           if(tiradasAtaque[0]<tiradasAtaque[1]){
                                              int aux=tiradasAtaque[0];
                                              tiradasAtaque[0]=tiradasAtaque[1];
                                              tiradasAtaque[1]=aux;
                                           }
                                           System.out.println("Tirada de Ataque: "+tiradasAtaque[0]+", "+tiradasAtaque[1]);
                                           System.out.println("Tirada de Defensa: "+tiradasDefensa[0]);
                                           if (tiradasAtaque[0]>tiradasDefensa[0]){
                                              int nuevoNumTropas=Territorios.get(tDestino).getNumTropas()-1;
                                              Territorios.get(tDestino).setNumTropas(nuevoNumTropas);
                                              System.out.println("¡¡BABOOM!! El territorio "+Territorios.get(tDestino).getIdentificador()+" - "+Territorios.get(tDestino).getNomTerritorio()+" ha perdido una tropa");
                                              if (Territorios.get(tDestino).getNumTropas()==0){ 
                                                 System.out.println("El territorio "+Territorios.get(tDestino).getIdentificador()+" - "+Territorios.get(tDestino).getNomTerritorio()+" ha sido conquistado por "+getjugadores(gettur()).getNombre() );
                                                  if(!(tieneZonaCompleta(poseedorterritorio(Territorios.get(tDestino)).getIdentificador(), Territorios.get(tDestino).getZona()))){
                                                    int z=Territorios.get(tDestino).getZona();
                                                    tablero.getZona(z).setJugadorPoseedor(-1);
                                                    retorno=1;
                                
                                               }
                                               invadir(tOrigen,tDestino);
                                               System.out.println("Vamos a comprobar si el jugador ha conquistado la Zona");
                                               System.out.println("ID: "+ tablero.getZona(Territorios.get(tDestino).getZona()).getJugadorPoseedor());
                                               System.out.println("Zona: "+ Territorios.get(tDestino).getZona());
                                               if(tieneZonaCompleta(jugadores.get(gettur()).getIdentificador(), Territorios.get(tDestino).getZona())){
                                                  int z=Territorios.get(tDestino).getZona();
                                                  tablero.getZona(z).setJugadorPoseedor(jugadores.get(gettur()).getIdentificador());
                                                  System.out.println("El jugador "+tablero.getZona(z).getJugadorPoseedor()+" ahora posee la zona "+ tablero.getZona(z).getNomZona());
                                               }
                                              }
                                           }
                                           else {
                                                int nuevoNumTropas=Territorios.get(tOrigen).getNumTropas()-1;
                                                Territorios.get(tOrigen).setNumTropas(nuevoNumTropas);
                                                System.out.println("¡¡CATACROKET!! El territorio "+Territorios.get(tOrigen).getIdentificador()+" - "+Territorios.get(tOrigen).getNomTerritorio()+" ha perdido una tropa");
                                                retorno=2;
                                           } 
                                           break;
                                           //else invadir(tOrigen,tDestino);
                                          
                    }
                    break;    
            case 3: switch(tropasDestino){
                                   case 2:d1.tirarDado();
                                          //d2.tirarDado();
                                          //d3.tirarDado();
                                          tiradasAtaque[0]=d1.getValorCara();
                                          d1.tirarDado();
                                          tiradasAtaque[1]=d1.getValorCara();
                                          d1.tirarDado();
                                          tiradasAtaque[2]=d1.getValorCara();
                                          d1.tirarDado();
                                          tiradasDefensa[0]=d1.getValorCara();
                                          d1.tirarDado();
                                          tiradasDefensa[1]=d1.getValorCara();
                                          //tiradasDefensa[1]=d5.getValorCara();
                                          for(int i=0;i<tiradasAtaque.length;i++){
                                          for(int k=0;k<tiradasAtaque.length;k++){
                                              if(tiradasAtaque[i]>tiradasAtaque[k]){
                                                  int aux=tiradasAtaque[i];
                                                  tiradasAtaque[i]=tiradasAtaque[k];
                                                  tiradasAtaque[k]=aux;
                                              }
                                          }
                                      }
                                          if(tiradasDefensa[0]<tiradasDefensa[1]){
                                              int aux=tiradasDefensa[0];
                                              tiradasDefensa[0]=tiradasDefensa[1];
                                              tiradasDefensa[1]=aux;
                                          }
                                          System.out.println("Tirada de Ataque: "+tiradasAtaque[0]+", "+tiradasAtaque[1]+", "+tiradasAtaque[2]);
                                          System.out.println("Tirada de Defensa: "+tiradasDefensa[0]+", "+tiradasDefensa[1]);
                                          if(tiradasAtaque[0]>tiradasDefensa[0]){
                                             int nuevoNumTropas=Territorios.get(tDestino).getNumTropas()-1;
                                             Territorios.get(tDestino).setNumTropas(nuevoNumTropas);
                                             System.out.println("¡¡BOOOM!! El territorio "+Territorios.get(tDestino).getIdentificador()+" - "+Territorios.get(tDestino).getNomTerritorio()+" ha perdido una tropa");
                                            
                                             if (Territorios.get(tDestino).getNumTropas()==0){ 
                                                 victoria=true;
                                                //System.out.println("El territorio "+territorios.get(tDestino).getIdentificador()+" - "+territorios.get(tDestino).getNomTerritorio()+" ha sido conquistado por "+getjugadores(gettur()) );
                                                if(!(tieneZonaCompleta(poseedorterritorio(Territorios.get(tDestino)).getIdentificador(), Territorios.get(tDestino).getZona()))){
                                                    int z=Territorios.get(tDestino).getZona();
                                                    tablero.getZona(z).setJugadorPoseedor(-1);
                                
                                               }
                                               invadir(tOrigen,tDestino);
                                               System.out.println("Vamos a comprobar si el jugador ha conquistado la Zona");
                                               System.out.println("ID: "+ tablero.getZona(Territorios.get(tDestino).getZona()).getJugadorPoseedor());
                                               System.out.println("Zona: "+ Territorios.get(tDestino).getZona());
                                               if(tieneZonaCompleta(jugadores.get(gettur()).getIdentificador(), Territorios.get(tDestino).getZona())){
                                                  int z=Territorios.get(tDestino).getZona();
                                                  tablero.getZona(z).setJugadorPoseedor(jugadores.get(gettur()).getIdentificador());
                                                  System.out.println("El jugador "+tablero.getZona(z).getJugadorPoseedor()+" ahora posee la zona "+ tablero.getZona(z).getNomZona());
                                               }
                                             }
                                              retorno=1;
                                          }
                                          else {
                                               int nuevoNumTropas=Territorios.get(tOrigen).getNumTropas()-1;
                                               Territorios.get(tOrigen).setNumTropas(nuevoNumTropas);
                                               System.out.println("¡¡CRASH!! El territorio "+Territorios.get(tOrigen).getIdentificador()+" - "+Territorios.get(tOrigen).getNomTerritorio()+" ha perdido una tropa");
                                                retorno=2;
                                          }
                                          if(!victoria){
                                               if (tiradasAtaque[1]>tiradasDefensa[1]){
                                                    int nuevoNumTropas=Territorios.get(tDestino).getNumTropas()-1;
                                                    Territorios.get(tDestino).setNumTropas(nuevoNumTropas);
                                                    System.out.println("¡¡BABOOM!! El territorio "+Territorios.get(tDestino).getIdentificador()+" - "+Territorios.get(tDestino).getNomTerritorio()+" ha perdido una tropa");
                                                    if (Territorios.get(tDestino).getNumTropas()==0){ 
                                                        System.out.println("El territorio "+Territorios.get(tDestino).getIdentificador()+" - "+Territorios.get(tDestino).getNomTerritorio()+" ha sido conquistado por "+getjugadores(gettur()).getNombre() );
                                                        invadir(tOrigen,tDestino);
                                                    }
                                                     retorno=1;
                                               }
                                               else {
                                                    int nuevoNumTropas=Territorios.get(tOrigen).getNumTropas()-1;
                                                    Territorios.get(tOrigen).setNumTropas(nuevoNumTropas);
                                                    System.out.println("¡¡CATACROKET!! El territorio "+Territorios.get(tOrigen).getIdentificador()+" - "+Territorios.get(tOrigen).getNomTerritorio()+" ha perdido una tropa");
                                                     retorno=2;
                                               } 
                                           }
                                           else { if(!(tieneZonaCompleta(poseedorterritorio(Territorios.get(tDestino)).getIdentificador(), Territorios.get(tDestino).getZona()))){
                                                    int z=Territorios.get(tDestino).getZona();
                                                    tablero.getZona(z).setJugadorPoseedor(-1);
                                
                                               }
                                               invadir(tOrigen,tDestino);
                                               System.out.println("Vamos a comprobar si el jugador ha conquistado la Zona");
                                               System.out.println("ID: "+ tablero.getZona(Territorios.get(tDestino).getZona()).getJugadorPoseedor());
                                               System.out.println("Zona: "+ Territorios.get(tDestino).getZona());
                                               if(tieneZonaCompleta(jugadores.get(gettur()).getIdentificador(), Territorios.get(tDestino).getZona())){
                                                  int z=Territorios.get(tDestino).getZona();
                                                  tablero.getZona(z).setJugadorPoseedor(jugadores.get(gettur()).getIdentificador());
                                                  System.out.println("El jugador "+tablero.getZona(z).getJugadorPoseedor()+" ahora posee la zona "+ tablero.getZona(z).getNomZona());
                                               }
                                              
                                           }
                                           break;
                                   case 1: d1.tirarDado();
                                          //d2.tirarDado();
                                          //d3.tirarDado();
                                          tiradasAtaque[0]=d1.getValorCara();
                                          d1.tirarDado();
                                          tiradasAtaque[1]=d1.getValorCara();
                                          d1.tirarDado();
                                          tiradasAtaque[2]=d1.getValorCara();
                                           d1.tirarDado();
                                           tiradasDefensa[0]=d1.getValorCara();
                                            for(int i=0;i<tiradasAtaque.length;i++){
                                          for(int k=0;k<tiradasAtaque.length;k++){
                                              if(tiradasAtaque[i]>tiradasAtaque[k]){
                                                  int aux=tiradasAtaque[i];
                                                  tiradasAtaque[i]=tiradasAtaque[k];
                                                  tiradasAtaque[k]=aux;
                                              }
                                          }
                                      }
                                               System.out.println("Tirada de Ataque: "+tiradasAtaque[0]+", "+tiradasAtaque[1]+", "+tiradasAtaque[2]);
                                               System.out.println("Tirada de Defensa: "+tiradasDefensa[0]);
                                               if (tiradasAtaque[0]>tiradasDefensa[0]){
                                                    int nuevoNumTropas=Territorios.get(tDestino).getNumTropas()-1;
                                                    Territorios.get(tDestino).setNumTropas(nuevoNumTropas);
                                                    System.out.println("¡¡BABOOM!! El territorio "+Territorios.get(tDestino).getIdentificador()+" - "+Territorios.get(tDestino).getNomTerritorio()+" ha perdido una tropa");
                                                    if (Territorios.get(tDestino).getNumTropas()==0){ 
                                                        System.out.println("El territorio "+Territorios.get(tDestino).getIdentificador()+" - "+Territorios.get(tDestino).getNomTerritorio()+" ha sido conquistado por "+getjugadores(gettur()).getNombre() );
                                                         if(!(tieneZonaCompleta(poseedorterritorio(Territorios.get(tDestino)).getIdentificador(), Territorios.get(tDestino).getZona()))){
                                                    int z=Territorios.get(tDestino).getZona();
                                                    tablero.getZona(z).setJugadorPoseedor(-1);
                                
                                               }
                                               invadir(tOrigen,tDestino);
                                               System.out.println("Vamos a comprobar si el jugador ha conquistado la Zona");
                                               System.out.println("ID: "+ tablero.getZona(Territorios.get(tDestino).getZona()).getJugadorPoseedor());
                                               System.out.println("Zona: "+ Territorios.get(tDestino).getZona());
                                               if(tieneZonaCompleta(jugadores.get(gettur()).getIdentificador(), Territorios.get(tDestino).getZona())){
                                                  int z=Territorios.get(tDestino).getZona();
                                                  tablero.getZona(z).setJugadorPoseedor(jugadores.get(gettur()).getIdentificador());
                                                  System.out.println("El jugador "+tablero.getZona(z).getJugadorPoseedor()+" ahora posee la zona "+ tablero.getZona(z).getNomZona());
                                               }
                                                    }
                                                     retorno=1;
                                               }
                                               else {
                                                    int nuevoNumTropas=Territorios.get(tOrigen).getNumTropas()-1;
                                                    Territorios.get(tOrigen).setNumTropas(nuevoNumTropas);
                                                    System.out.println("¡¡CATACROKET!! El territorio "+Territorios.get(tOrigen).getIdentificador()+" - "+Territorios.get(tOrigen).getNomTerritorio()+" ha perdido una tropa");
                                                     retorno=2;
                                               } 
                                           break;
                                           //else invadir(tOrigen,tDestino);
                                          
                    }
                    break;
        }
        return retorno;
      
    }
    // <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*/) throws IOException
    {   
        InputStreamReader isr =new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        int torigen=-1,tdestino=-1,numTropasAtaque=0;
        Jugador jug;
        System.out.println("SELECCIONE EL TERRITORIO DE ORIGEN: ");
        muestraTerritoriosJugador(gettur());    
        System.out.println("Opcion: ");
        try{
            String opOrigen = br.readLine();
            torigen = Integer.parseInt(opOrigen);
        } catch (IOException ex) {
                   Logger.getLogger(Juego.class.getName()).log(Level.SEVERE, null, ex);
        }
        
        if(getjugadores(gettur()).ExisteTerritorio(Territorios.get(torigen))==true){
            if(Territorios.get(torigen).getNumTropas()>1){
                System.out.println("SELECCIONE EL TERRITORIO QUE SERÁ OBJETIVO DEL ATAQUE");
                muestraTerritoriosVecinos(torigen);
                System.out.println("Opcion: ");
                try{
                    String opDestino = br.readLine();
                    tdestino = Integer.parseInt(opDestino);
                } catch (IOException ex) {
                    Logger.getLogger(Juego.class.getName()).log(Level.SEVERE, null, ex);
                }
                if(getjugadores(gettur()).ExisteTerritorio(Territorios.get(tdestino))!=true){
                    System.out.println("\n\n\n\n\n\n\n\n\n¡¡ATAQUE!!:");
                    System.out.println("\nDesde :"+ Territorios.get(torigen).getIdentificador()+ " - " +Territorios.get(torigen).getNomTerritorio()+" a "+Territorios.get(tdestino).getIdentificador()+ " - " +Territorios.get(tdestino).getNomTerritorio());
                    System.out.println("Tropas:         "+Territorios.get(torigen).getNumTropas()+ "              " +Territorios.get(tdestino).getNumTropas());
                    System.out.println("¿Con cuantas tropas atacará?");
                    try{
                        String numTropas = br.readLine();
                        numTropasAtaque = Integer.parseInt(numTropas);
                    } catch (IOException ex) {
                        Logger.getLogger(Juego.class.getName()).log(Level.SEVERE, null, ex);
                    }
                    if(Territorios.get(torigen).getNumTropas()-numTropasAtaque>=1){
                        if (numTropasAtaque<4 && numTropasAtaque>0){
                            System.out.println("\nPulse una tecla para realizar las tiradas");
                            String numTropas = br.readLine();
                            System.out.println("BATALLA:\n");
                            switch(numTropasAtaque){
                                case 1: batalla(torigen,tdestino,1,1);break;
                                case 2: if(Territorios.get(tdestino).getNumTropas()==1)
                                           batalla(torigen,tdestino,2,1);
                                        else batalla(torigen,tdestino,2,2);
                                        break;
                                case 3: if(Territorios.get(tdestino).getNumTropas()==1)
                                        batalla(torigen,tdestino,3,1);
                                        else batalla(torigen,tdestino,3,2);
                                        break;
                            }
                        }
                    }
                    else System.out.println("Debes dejar al menos una tropa en el territorio de origen");
                    
                    
                    
                    
                }
                else System.out.println("Ese territorio es tuyo!!");
            } 
            else System.out.println("Debes tener mas de un batallón en ese territorio para atacar");
        }
        else System.out.println("El territorio que has seleccionado no te pertence");
    }
 
    
    
 //***********************************************************
    // <editor-fold defaultstate="collapsed" desc=" UML Marker "> 
    // #[regen=yes,id=DCE.0BA91DB7-C764-693A-2FA4-C68885F8B88A]
    // </editor-fold> er
    public void invadir(int tOrigen,int tDestino){
        InputStreamReader isr =new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        int numTropasInvasion=0;
        boolean correcto=false;
        do{    
            System.out.println("Vas a invadir: "+Territorios.get(tDestino).getIdentificador()+" - "+Territorios.get(tDestino).getNomTerritorio() );
            System.out.println("Desde :        "+Territorios.get(tOrigen).getIdentificador()+" - "+Territorios.get(tOrigen).getNomTerritorio());
            System.out.println("Tropas disponibles: "+Territorios.get(tOrigen).getNumTropas());
            System.out.println("¿Con cuantas tropas quieres ocupar "+Territorios.get(tDestino).getNomTerritorio()+"?");
            try{
                 String numTropas = br.readLine();
                 numTropasInvasion = Integer.parseInt(numTropas);
            } catch (IOException ex) {
                Logger.getLogger(Juego.class.getName()).log(Level.SEVERE, null, ex);
              }
            if(numTropasInvasion>Territorios.get(tOrigen).getNumTropas()-1){
                System.out.println("No puedes dejar el "+Territorios.get(tOrigen).getNomTerritorio()+" vacío");
            }
            else{
                Jugador jugadorInvasor=poseedorterritorio(Territorios.get(tOrigen));
                Jugador jugadorInvadido=poseedorterritorio(Territorios.get(tDestino));
                jugadorInvadido.quitarTerritorio(Territorios.get(tDestino));
                jugadorInvasor.setTerritorio(Territorios.get(tDestino));
                Territorios.get(tDestino).setNumTropas(numTropasInvasion);
                Territorios.get(tOrigen).setNumTropas(Territorios.get(tOrigen).getNumTropas()-numTropasInvasion);
                correcto=true;
            }
            
        }while(!correcto);
        Jugador comprobacion=poseedorterritorio(Territorios.get(tDestino));
        System.out.println(Territorios.get(tDestino).getNomTerritorio()+ " pertenece ahora a "+comprobacion.getNombre()+" y está ocupado por "+Territorios.get(tDestino).getNumTropas()+" batallones");
        
    
    }
    
    public void transferencia(){
        InputStreamReader isr =new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        int torigen=-1,tdestino=-1;
        boolean correcto=false;
        Jugador jug;
        System.out.println("SELECCIONE EL TERRITORIO DE ORIGEN: ");
        muestraTerritoriosJugador(gettur());    
        System.out.println("Opcion: ");
        try{
            String opOrigen = br.readLine();
            torigen = Integer.parseInt(opOrigen);
        } catch (IOException ex) {
                   Logger.getLogger(Juego.class.getName()).log(Level.SEVERE, null, ex);
        }
        
        if(getjugadores(gettur()).ExisteTerritorio(Territorios.get(torigen))==true){
            if(Territorios.get(torigen).getNumTropas()>1){
                System.out.println("SELECCIONE EL TERRITORIO DE DESTINO");
                muestraTerritoriosVecinos(torigen);
                System.out.println("Opcion: ");
                try{
                    String opDestino = br.readLine();
                    tdestino = Integer.parseInt(opDestino);
                } catch (IOException ex) {
                    Logger.getLogger(Juego.class.getName()).log(Level.SEVERE, null, ex);
                }
                if(getjugadores(gettur()).ExisteTerritorio(Territorios.get(tdestino))==true){
                   do{     
                        correcto=transferir(torigen,tdestino);
                   }while(!correcto);
                }
            }
        }
    }
    
    public boolean transferir(int tOrigen,int tDestino){
        if (jugadores.get(gettur()).ExisteTerritorio(Territorios.get(tOrigen))&& jugadores.get(gettur()).ExisteTerritorio(Territorios.get(tDestino))){
            InputStreamReader isr =new InputStreamReader(System.in);
            BufferedReader br = new BufferedReader(isr);
            int numTropasTransferencia=0;
            boolean correcto=false;
            do{    
                System.out.println("Vas a transferir tropas a : "+Territorios.get(tDestino).getIdentificador()+" - "+Territorios.get(tDestino).getNomTerritorio() );
                System.out.println("Desde :                     "+Territorios.get(tOrigen).getIdentificador()+" - "+Territorios.get(tOrigen).getNomTerritorio());
                System.out.println("Tropas disponibles: "+Territorios.get(tOrigen).getNumTropas());
                System.out.println("¿Cuantas tropas quieres enviar a "+Territorios.get(tDestino).getNomTerritorio()+"?");
                try{
                    String numTropas = br.readLine();
                    numTropasTransferencia = Integer.parseInt(numTropas);
                } catch (IOException ex) {
                    Logger.getLogger(Juego.class.getName()).log(Level.SEVERE, null, ex);
                }
                if(numTropasTransferencia>Territorios.get(tOrigen).getNumTropas()-1){
                    System.out.println("No puedes dejar el "+Territorios.get(tOrigen).getNomTerritorio()+" vacío");
                }
                else{
                    Territorios.get(tDestino).setNumTropas(Territorios.get(tDestino).getNumTropas()+numTropasTransferencia);
                    Territorios.get(tOrigen).setNumTropas(Territorios.get(tOrigen).getNumTropas()-numTropasTransferencia);
                    correcto=true;
                }
            
            }while(!correcto);
            return true;
        }
        else if (!jugadores.get(gettur()).ExisteTerritorio(Territorios.get(tOrigen))){
            System.out.println(Territorios.get(tOrigen).getNomTerritorio()+" no es tuyo!!");
            return false;
        } 
        else{ 
            System.out.println(Territorios.get(tOrigen).getNomTerritorio()+" no es tuyo!!"); 
            return false;
        }
    }
    
public boolean ubicarUnidad(Territorio t){
    return true;
}
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=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(Territorios.get(indica_territorio))){
                
                int nuevoNum=0;
                nuevoNum=Territorios.get(indica_territorio).getNumTropas()+1;
                Territorios.get(indica_territorio).setNumTropas(nuevoNum);
                int nuevaTrop=getjugadores(gettur()).getTropasPendUbicar()-1;
                System.out.println("UBICAR: Al jugador "+getjugadores(gettur()).getNombre()+" le quedan "+getjugadores(gettur()).getTropasPendUbicar()+" antes de la actualizacion");
                getjugadores(gettur()).setTropasPendUbicar(nuevaTrop);
                System.out.println("El territorio "+Territorios.get(indica_territorio).getNomTerritorio()+" ahora tiene "+Territorios.get(indica_territorio).getNumTropas());
                //correcto=true;
                System.out.println("UBICAR: Al jugador "+getjugadores(gettur()).getNombre()+" le quedan "+getjugadores(gettur()).getTropasPendUbicar());

                
            }
            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(Territorios.get(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();
            System.out.println("FASE PREVIA: Al jugador "+getjugadores(gettur()).getNombre()+" le quedan "+getjugadores(gettur()).getTropasPendUbicar());
            getturnoFasePrevia();
            
            
        }
    }
    
    public void reparteTerritorios(){
        int jug=0;
        for(int i=0;i<52;i++){
            if(jug==numJugadores)jug=0;
            getjugadores(jug).setTerritorio(Territorios.get(i));
            jug++;
        }
        
    }
    /*public void reparteTerritorios(){//prueba para la conquitas de las zonas
        int jug=0;
        for(int i=9;i<18;i++){
            getjugadores(jug).setTerritorio(Territorios.get(i));
        }
        jug++;
        for(int i=0;i<9;i++){
            getjugadores(jug).setTerritorio(Territorios.get(i));
        }
        jug++;
        for(int i=18;i<52;i++){
            if(jug==numJugadores)jug=0;
            getjugadores(jug).setTerritorio(Territorios.get(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;
    }
     //***********************************************************

public void calc_rearmamiento(int nterritorio){
      int resultado=0;
      int ntropaspend=0;
      for(int i=0; i<tablero.getNumZonas(); i++)
      { //*************************************************************************
          if(getjugadores(gettur()).getIdentificador()==tablero.getZona(i).getJugadorPoseedor())
          //***********************************************************************
          {
              
              ntropaspend=ntropaspend+tablero.getZona(i).getBonusEjercitos();//bonus de zona
          }
      }
      if(nterritorio<=9 && nterritorio>0)
         ntropaspend=ntropaspend+3;
      else{
          int cociente=0;
          cociente=nterritorio/3;
          ntropaspend=ntropaspend+cociente;
      }
              
      getjugadores(gettur()).setTropasPendUbicar(ntropaspend);
     
  }
  
  public void rearmamiento()
  {
       InputStreamReader isra =new InputStreamReader(System.in);
            BufferedReader bra = new BufferedReader(isra);
             int tropasturno=getjugadores(gettur()).getTropasPendUbicar();
             int indica_territorios=0;
             int indica_tropas=0;
             
      if(tropasturno>0)
      {
          do{
      
         System.out.println("*****  REARMAMIENTO  *********");
         System.out.println("Introduce el territorio a rearmar");
      
         getjugadores(gettur()).muestraTerritorios();// mostramos los territorios  
         System.out.println("OpciÃ³n:");
            
             try {
                 String numeroterri = bra.readLine();
                 indica_territorios = Integer.parseInt(numeroterri);
             } catch (IOException ex) {
                     Logger.getLogger(Juego.class.getName()).log(Level.SEVERE, null, ex);
             }
         
           if(getjugadores(gettur()).ExisteTerritorio(Territorios.get(indica_territorios))==true)
           {
             System.out.println("El numero de tropas pendientes de ubicar son:" +getjugadores(gettur()).getTropasPendUbicar());
             System.out.println("Introduce el numero de tropas a rearmar: ");
                try {
                   String numerotropas = bra.readLine();
                      indica_tropas = Integer.parseInt(numerotropas);
                  } catch (IOException ex) {
                       Logger.getLogger(Juego.class.getName()).log(Level.SEVERE, null, ex);
                  }
               if(indica_tropas>0 && indica_tropas<=getjugadores(gettur()).getTropasPendUbicar())
               {
                 int numTropas=Territorios.get(indica_territorios).getNumTropas()+indica_tropas;
                 Territorios.get(indica_territorios).setNumTropas(numTropas);
                 int tg=getjugadores(gettur()).getTropasPendUbicar();
                 getjugadores(gettur()).setTropasPendUbicar(tg-indica_tropas);
                 
               }
               else
                   System.out.println("El numero de tropas es incorrecto ");
                   
           }
      }while(getjugadores(gettur()).getTropasPendUbicar()!=0);
    }//if
    else
        System.out.println("No tienes tropas pendiente de ubicar");
               
}
//*********************************************************
public boolean tieneZonaCompleta(int idJugador, int idZona){
    Zona z=tablero.getZona(idZona);
    Jugador jug=jugadores.get(idJugador);
    int maximo=jug.getNumTerritorios();
    boolean correcto=true;
    boolean encontrado=false;
    for(int i=0;i<z.getNumTerritorios()&&!correcto;i++){
        int buscado=z.getTerritorio(i).getIdentificador();
        int j=0;
        while(!encontrado || j<maximo){
            if(jug.getTerritorio(j).getIdentificador()==buscado)encontrado=true;
            else j++;
        }
        if(!encontrado)correcto=false;
    }
    return correcto;
    
}

public Territorio getTerrtiorio(int i){
    return Territorios.get(i);
}

public void crearcartas() throws IOException{
        InputStreamReader isr = new InputStreamReader(System.in);
        FileReader flujo = null;
        try {
            flujo = new FileReader("cartas.txt");
        } catch (FileNotFoundException ex) {
            Logger.getLogger(Juego.class.getName()).log(Level.SEVERE, null, ex);
        }
        BufferedReader fichero=new BufferedReader(flujo);
        String sCadena=fichero.readLine();
        while(!sCadena.contentEquals("EOF")){
                int idcarta=Integer.parseInt(sCadena);
                String nomCarta=fichero.readLine();
                int numTropa=Integer.parseInt(sCadena);
                Carta c= new Carta(idcarta,nomCarta,numTropa);
                Cartas.add(c);
                sCadena=fichero.readLine();
        }
}

public void repartoCartas(){
    Random rnd=new Random();
    int llena=1;
    int numjug=0;
    int [] cuenta=new int[numJugadores];    
    for (int j=0;j<numJugadores;j++)
        cuenta[j]=0;
    System.out.println("hay "+numJugadores+" jugadores");
    System.out.println("repartiendo cartas...");
    for(int i=0;i<Cartas.size();i++){
      for (int k=0;k<numJugadores;k++){//comprobamos si esta llena
          if(cuenta[k]==0)
              llena=0;
       System.out.println("for 2");
       System.out.println(" lleno de for2 :"+llena);
      }
      System.out.println("size");
      if(llena==1){
         for (int j=0;j<numJugadores;j++){ //reseteamos 
           cuenta[j]=0;
           llena=1;
           System.out.println("for 3");
         }
      }
      else{ 
          System.out.println("else ded los cojoen");
        int idterri=Cartas.get(i).getIdCarta();
        numjug=rnd.nextInt(numJugadores);
        while(cuenta[numjug]!=0){
          numjug=rnd.nextInt(numJugadores);
          getjugadores(numjug).setTerritorio(Territorios.get(idterri));
          cuenta[numjug]=1;
        }
      }
   }
}
  
}







